public VsSolution(DteSolution dteSolution, ISolutionManager solutionManager, IVsPackageManager packageManager)
{
_name = String.Format(
CultureInfo.CurrentCulture,
Strings.Label_Solution,
dteSolution.GetName());
_solution = solutionManager;
_packageManager = packageManager;
var repo = (SharedPackageRepository)packageManager.LocalRepository;
_installedSolutionLevelPackages = new CoreInteropInstalledPackagesList(
new PackageReferenceRepository(repo.PackageReferenceFile.FullPath, repo));
DteSolution = dteSolution;
// Add V2-related interop features
AddFeature(() => packageManager.LocalRepository);
AddFeature<IPackageManager>(() => packageManager);
AddFeature<IPackageCacheRepository>(() => MachineCache.Default);
// the source repository of the local repo of the solution
AddFeature<SourceRepository>(() =>
{
var localRepo = new NuGet.Client.Interop.V2SourceRepository(
null,
packageManager.LocalRepository,
"");
return localRepo;
});
// Add PowerShell feature
AddFeature<PowerShellScriptExecutor>(() =>
new VsPowerShellScriptExecutor(ServiceLocator.GetInstance<IScriptExecutor>()));
}
protected internal override IVsPackageManager GetActivePackageManager()
{
if (_recentPackageManager == null)
{
var repository = _packageRepositoryFactory.CreateRepository(_aggregateSource);
_recentPackageManager = _packageManagerFactory.CreatePackageManager(repository);
}
return(_recentPackageManager);
}
protected internal override IVsPackageManager GetActivePackageManager()
{
if (_recentPackageManager == null)
{
var repository = _packageSourceProvider.GetAggregate(_packageRepositoryFactory, ignoreFailingRepositories: true);
_recentPackageManager = _packageManagerFactory.CreatePackageManager(repository, useFallbackForDependencies: false);
}
return(_recentPackageManager);
}
protected internal override IVsPackageManager GetActivePackageManager()
{
if (_recentPackageManager == null)
{
var repository = _packageSourceProvider.GetAggregate(_packageRepositoryFactory, ignoreFailingRepositories: true);
_recentPackageManager = _packageManagerFactory.CreatePackageManager(repository, useFallbackForDependencies: false);
}
return _recentPackageManager;
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
var provider = CreateOnlineProvider(packageManager.Object, projectManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate {
// Assert
mockPackageManager.Verify(p => p.InstallPackage(projectManager.Object, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB, null);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
private void InstallPackage(IVsPackageManager packageManager)
{
if (packageManager == null)
{
return;
}
packageManager.DependencyVersion = DependencyVersion;
packageManager.WhatIf = WhatIf;
packageManager.InstallPackage(ProjectManager, Id, Version, IgnoreDependencies, IncludePrerelease.IsPresent, logger: this);
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IProjectManager projectManager,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider)
: base(project, projectManager, resources, providerServices, progressProvider)
{
_packageManager = packageManager;
}
internal void InstallPackage(IPackageRepository repository, Project project, string packageId, SemanticVersion version, bool ignoreDependencies, bool skipAssemblyReferences)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
using (_vsCommonOperations.SaveSolutionExplorerNodeStates(_solutionManager))
{
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager(repository,
useFallbackForDependencies: false);
IProjectManager projectManager = packageManager.GetProjectManager(project);
EventHandler <PackageOperationEventArgs> installedHandler = (sender, e) =>
{
_scriptExecutor.ExecuteInitScript(
e.InstallPath, e.Package,
NullLogger.Instance);
};
EventHandler <PackageOperationEventArgs> addedHandler = (sender, e) =>
{
_scriptExecutor.ExecuteScript(
e.InstallPath,
PowerShellScripts.Install,
e.Package,
project,
project.GetTargetFrameworkName(),
NullLogger.Instance);
};
bool oldBindingRedirectValue = packageManager.BindingRedirectEnabled;
try
{
projectManager.PackageReferenceAdded += addedHandler;
packageManager.PackageInstalled += installedHandler;
packageManager.BindingRedirectEnabled = false;
packageManager.InstallPackage(
projectManager,
packageId,
version,
ignoreDependencies,
allowPrereleaseVersions: true,
skipAssemblyReferences: skipAssemblyReferences,
logger: NullLogger.Instance);
}
finally
{
packageManager.BindingRedirectEnabled = oldBindingRedirectValue;
projectManager.PackageReferenceAdded -= addedHandler;
packageManager.PackageInstalled -= installedHandler;
}
}
}
private void EnablePackageRestore(bool fromActivation)
{
EnsureNuGetBuild(fromActivation);
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager();
foreach (Project project in _solutionManager.GetProjects())
{
EnablePackageRestore(project, packageManager);
}
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IProjectManager projectManager,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider)
: base(project, projectManager, resources, providerServices, progressProvider)
{
_packageManager = packageManager;
}
public SolutionInstalledProvider(
IVsPackageManager packageManager,
IPackageRepository localRepository,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider,
ISolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager)
: base(packageManager, null, localRepository, resources, providerServices, progressProvider, solutionManager, packageRestoreManager)
{
_userNotifierServices = providerServices.UserNotifierServices;
}
public SolutionInstalledProvider(
IVsPackageManager packageManager,
IPackageRepository localRepository,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider,
ISolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager)
: base(packageManager, null, localRepository, resources, providerServices, progressProvider, solutionManager, packageRestoreManager)
{
_userNotifierServices = providerServices.UserNotifierServices;
}
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"));
}
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager(_packageRepository, useFallbackForDependencies: false);
IProjectManager projectManager = packageManager.GetProjectManager(project);
EventHandler <PackageOperationEventArgs> packageReferenceRemovingHandler = (sender, e) =>
{
_scriptExecutor.Execute(
e.InstallPath,
PowerShellScripts.Uninstall,
e.Package,
project,
projectManager.GetTargetFrameworkForPackage(packageId),
NullLogger.Instance);
};
try
{
projectManager.PackageReferenceRemoving += packageReferenceRemovingHandler;
// Locate the package to uninstall
IPackage package = packageManager.LocatePackageToUninstall(
projectManager,
packageId,
version: null);
// resolve actions
var resolver = new ActionResolver()
{
RemoveDependencies = removeDependencies
};
resolver.AddOperation(PackageAction.Uninstall, package, projectManager);
var actions = resolver.ResolveActions();
// execute actions
var actionExecutor = new ActionExecutor();
actionExecutor.Execute(actions);
}
finally
{
projectManager.PackageReferenceRemoving -= packageReferenceRemovingHandler;
}
}
private void EnablePackageRestore(Project project, IVsPackageManager packageManager)
{
var projectManager = packageManager.GetProjectManager(project);
if (projectManager.LocalRepository.GetPackages().IsEmpty())
{
// don't enable package restore for the project if it doesn't have at least one
// nuget package installed
return;
}
EnablePackageRestore(project);
}
protected bool CheckPSScriptAndShowLicenseAgreement(PackageItem item, IVsPackageManager packageManager, out IList <PackageOperation> operations)
{
ShowProgressWindow();
CheckInstallPSScripts(
item.PackageIdentity,
packageManager.SourceRepository,
_project.GetTargetFrameworkName(),
IncludePrerelease,
out operations);
return(ShowLicenseAgreement(packageManager, operations));
}
private bool CheckForMissingPackagesCore()
{
// this can happen during unit tests
if (_packageManagerFactory == null)
{
return(false);
}
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager();
IPackageRepository localRepository = packageManager.LocalRepository;
var projectReferences = GetAllPackageReferences(packageManager);
return(projectReferences.Any(reference => !localRepository.Exists(reference.Id, reference.Version)));
}
protected override bool ExecuteCore(PackageItem item)
{
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
using (activePackageManager.SourceRepository.StartOperation(OperationName, item.Id, item.Version))
{
ShowProgressWindow();
// Resolve operations
var resolver = new ActionResolver()
{
Logger = this,
DependencyVersion = activePackageManager.DependencyVersion,
IgnoreDependencies = false,
AllowPrereleaseVersions = IncludePrerelease
};
var projectManager = activePackageManager.GetProjectManager(_project);
projectManager.Logger = this;
resolver.AddOperation(PackageAction.Install, item.PackageIdentity, projectManager);
var actions = resolver.ResolveActions();
// show license agreeement
bool acceptLicense = ShowLicenseAgreement(actions);
if (!acceptLicense)
{
return(false);
}
// execute operations
try
{
RegisterPackageOperationEvents(activePackageManager, projectManager);
var actionExecutor = new ActionExecutor()
{
Logger = this
};
actionExecutor.Execute(actions);
}
finally
{
UnregisterPackageOperationEvents(activePackageManager, projectManager);
}
return(true);
}
}
public MockPackagesProvider(IPackageRepository localRepository, IVsPackageManager packageManagerr, IEnumerable <string> supportedFrameworks)
: base(localRepository,
new ResourceDictionary(),
new ProviderServices(
new Mock <IUserNotifierServices>().Object,
new Mock <IProgressWindowOpener>().Object,
new Mock <IProviderSettings>().Object,
new Mock <IScriptExecutor>().Object,
new MockOutputConsoleProvider(),
new Mock <IVsCommonOperations>().Object),
new Mock <IProgressProvider>().Object,
new Mock <ISolutionManager>().Object)
{
_supportedFrameworks = supportedFrameworks;
}
public MockPackagesProvider(IPackageRepository localRepository, IVsPackageManager packageManagerr, IEnumerable<string> supportedFrameworks)
: base(localRepository,
new ResourceDictionary(),
new ProviderServices(
new Mock<IUserNotifierServices>().Object,
new Mock<IProgressWindowOpener>().Object,
new Mock<IProviderSettings>().Object,
new Mock<IScriptExecutor>().Object,
new MockOutputConsoleProvider(),
new Mock<IVsCommonOperations>().Object),
new Mock<IProgressProvider>().Object,
new Mock<ISolutionManager>().Object)
{
_supportedFrameworks = supportedFrameworks;
}
/// <summary>
/// Gets all package references in all projects of the current solution plus package
/// references specified in the solution packages.config
/// </summary>
private IEnumerable <PackageReference> GetAllPackageReferences(IVsPackageManager packageManager)
{
IEnumerable <PackageReference> projectReferences = from project in _solutionManager.GetProjects()
from reference in GetPackageReferences(packageManager.GetProjectManager(project))
select reference;
var localRepository = packageManager.LocalRepository as SharedPackageRepository;
if (localRepository != null)
{
IEnumerable <PackageReference> solutionReferences = localRepository.PackageReferenceFile.GetPackageReferences();
return(projectReferences.Concat(solutionReferences).Distinct());
}
return(projectReferences.Distinct());
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
FrameworkName targetFramework,
out IList <PackageOperation> operations)
{
var walker = new InstallWalker(
LocalRepository,
packageManager.SourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
operations = walker.ResolveOperations(package).ToList();
return(ShowLicenseAgreement(packageManager, operations));
}
public Task RestoreMissingPackages()
{
TaskScheduler uiScheduler;
try
{
uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
}
catch (InvalidOperationException)
{
// this exception occurs during unit tests
uiScheduler = TaskScheduler.Default;
}
Task task = Task.Factory.StartNew(() =>
{
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager();
IPackageRepository localRepository = packageManager.LocalRepository;
var projectReferences = GetAllPackageReferences(packageManager);
foreach (var reference in projectReferences)
{
if (!localRepository.Exists(reference.Id, reference.Version))
{
packageManager.InstallPackage(reference.Id, reference.Version, ignoreDependencies: true, allowPrereleaseVersions: true);
}
}
});
task.ContinueWith(originalTask =>
{
if (originalTask.IsFaulted)
{
ExceptionHelper.WriteToActivityLog(originalTask.Exception);
}
else
{
// we don't allow canceling
Debug.Assert(!originalTask.IsCanceled);
// after we're done with restoring packages, do the check again
CheckForMissingPackages();
}
}, uiScheduler);
return(task);
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList <PackageOperation> allOperations, out IList <IPackage> packagesByDependencyOrder)
{
allOperations = new List <PackageOperation>();
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
return(ShowLicenseAgreement(activePackageManager, allOperations));
}
protected override bool ExecuteAllCore()
{
if (SelectedNode == null || SelectedNode.Extensions == null || SelectedNode.Extensions.Count == 0)
{
return(false);
}
ShowProgressWindow();
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
IDisposable action = activePackageManager.SourceRepository.StartOperation(OperationName);
IProjectManager projectManager = activePackageManager.GetProjectManager(_project);
List <PackageOperation> allOperations;
bool accepted = ShowLicenseAgreementForAllPackages(activePackageManager, out allOperations);
if (!accepted)
{
return(false);
}
try
{
RegisterPackageOperationEvents(activePackageManager, projectManager);
var allUpdatePackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
activePackageManager.UpdatePackages(
projectManager,
allUpdatePackages,
allOperations,
updateDependencies: true,
allowPrereleaseVersions: IncludePrerelease,
logger: this);
return(true);
}
finally
{
UnregisterPackageOperationEvents(activePackageManager, projectManager);
action.Dispose();
}
}
/*
* protected override void ExecuteCommand(IProjectManager projectManager, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
* {
* activePackageManager.UpdatePackages(
* projectManager,
* new[] { item.PackageIdentity },
* operations,
* updateDependencies: true,
* allowPrereleaseVersions: IncludePrerelease,
* logger: this);
* } */
private IEnumerable <Resolver.PackageAction> ResolveActionsForUpdateAll(IVsPackageManager activePackageManager, IProjectManager projectManager)
{
var resolver = new ActionResolver()
{
Logger = this,
AllowPrereleaseVersions = IncludePrerelease,
DependencyVersion = activePackageManager.DependencyVersion
};
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
foreach (var package in allPackages)
{
resolver.AddOperation(PackageAction.Install, package, projectManager);
}
var actions = resolver.ResolveActions();
return(actions);
}
private void InstallPackage(IVsPackageManager packageManager)
{
if (packageManager == null)
{
return;
}
// Locate the package to install
IPackage package = PackageRepositoryHelper.ResolvePackage(
packageManager.SourceRepository,
packageManager.LocalRepository,
Id,
Version,
IncludePrerelease.IsPresent);
// Resolve actions
var resolver = new ActionResolver()
{
Logger = this,
IgnoreDependencies = IgnoreDependencies,
DependencyVersion = packageManager.DependencyVersion,
AllowPrereleaseVersions = IncludePrerelease.IsPresent
};
resolver.AddOperation(PackageAction.Install, package, ProjectManager);
var actions = resolver.ResolveActions();
if (WhatIf)
{
foreach (var action in actions)
{
Log(MessageLevel.Info, Resources.Log_OperationWhatIf, action);
}
return;
}
var executor = new ActionExecutor()
{
Logger = this
};
executor.Execute(actions);
}
protected override bool ExecuteCore(PackageItem item)
{
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
using (activePackageManager.SourceRepository.StartOperation(OperationName))
{
IList <PackageOperation> operations;
bool acceptLicense = CheckPSScriptAndShowLicenseAgreement(item, activePackageManager, out operations);
if (!acceptLicense)
{
return(false);
}
ExecuteCommandOnProject(_project, item, activePackageManager, operations);
return(true);
}
}
protected override bool ExecuteAllCore()
{
if (SelectedNode == null || SelectedNode.Extensions == null || SelectedNode.Extensions.Count == 0)
{
return(false);
}
ShowProgressWindow();
_activePackageManager = GetActivePackageManager();
Debug.Assert(_activePackageManager != null);
IDisposable action = _activePackageManager.SourceRepository.StartOperation(OperationName, mainPackageId: null, mainPackageVersion: null);
try
{
IList <PackageOperation> allOperations;
IList <IPackage> allUpdatePackagesByDependencyOrder;
bool accepted = ShowLicenseAgreementForAllPackages(_activePackageManager, out allOperations, out allUpdatePackagesByDependencyOrder);
if (!accepted)
{
return(false);
}
RegisterPackageOperationEvents(_activePackageManager, null);
_activePackageManager.UpdateSolutionPackages(
allUpdatePackagesByDependencyOrder,
allOperations,
updateDependencies: true,
allowPrereleaseVersions: IncludePrerelease,
logger: this,
eventListener: this);
return(true);
}
finally
{
UnregisterPackageOperationEvents(_activePackageManager, null);
action.Dispose();
}
}
protected override bool ExecuteAllCore()
{
if (SelectedNode == null || SelectedNode.Extensions == null || SelectedNode.Extensions.Count == 0)
{
return(false);
}
ShowProgressWindow();
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
IDisposable action = activePackageManager.SourceRepository.StartOperation(OperationName, mainPackageId: null, mainPackageVersion: null);
IProjectManager projectManager = activePackageManager.GetProjectManager(_project);
var actions = ResolveActionsForUpdateAll(activePackageManager, projectManager);
bool accepted = this.ShowLicenseAgreement(actions);
if (!accepted)
{
return(false);
}
try
{
RegisterPackageOperationEvents(activePackageManager, projectManager);
var actionExecutor = new ActionExecutor()
{
Logger = this
};
actionExecutor.Execute(actions);
return(true);
}
finally
{
UnregisterPackageOperationEvents(activePackageManager, projectManager);
action.Dispose();
}
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IPackageRepository localRepository,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider,
ISolutionManager solutionManager)
: base(localRepository, resources, providerServices, progressProvider, solutionManager)
{
if (packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
_packageManager = packageManager;
_project = project;
_userNotifierServices = providerServices.UserNotifierServices;
}
private bool CheckForMissingPackagesCore()
{
// this can happen during unit tests
if (_packageManagerFactory == null)
{
return(false);
}
try
{
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager();
IPackageRepository localRepository = packageManager.LocalRepository;
var projectReferences = GetAllPackageReferences(packageManager);
return(projectReferences.Any(reference => !localRepository.Exists(reference.Id, reference.Version)));
}
catch (Exception exception)
{
// if an exception happens during the check, assume no missing packages and move on.
ExceptionHelper.WriteToActivityLog(exception);
return(false);
}
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager)
{
var allOperations = new List <PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease).ToList();
foreach (var package in allPackages)
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var operations = installWalker.ResolveOperations(package);
allOperations.AddRange(operations);
}
return(ShowLicenseAgreement(activePackageManager, allOperations.Reduce()));
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IPackageRepository localRepository,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider,
ISolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager)
: base(localRepository, resources, providerServices, progressProvider, solutionManager)
{
if (packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
_packageManager = packageManager;
_project = project;
_targetFramework = _project.GetTargetFrameworkName();
_userNotifierServices = providerServices.UserNotifierServices;
_packageRestoreManager = packageRestoreManager;
_packageRestoreManager.PackagesMissingStatusChanged += OnMissPackagesChanged;
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IPackageRepository localRepository,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider,
ISolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager)
: base(localRepository, resources, providerServices, progressProvider, solutionManager)
{
if (packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
_packageManager = packageManager;
_project = project;
_targetFramework = _project.GetTargetFrameworkName();
_userNotifierServices = providerServices.UserNotifierServices;
_packageRestoreManager = packageRestoreManager;
_packageRestoreManager.PackagesMissingStatusChanged += OnMissPackagesChanged;
}
private static void VisitProjects(IVsPackageManager packageManager, SolutionManager solutionManager, List <DGMLNode> nodes, List <DGMLLink> links)
{
foreach (var project in solutionManager.GetProjects())
{
var projectManager = packageManager.GetProjectManager(project);
var repo = projectManager.LocalRepository;
if (!repo.GetPackages().Any())
{
// Project has no packages. Ignore it.
continue;
}
// Project has packages. Add a node for it
nodes.Add(new DGMLNode {
Name = project.GetCustomUniqueName(), Label = project.GetDisplayName(), Category = Resources.Visualizer_Project
});
var dependencies = VisitProjectPackages(nodes, links, repo);
var installedPackages = repo.GetPackages().Except(dependencies);
links.AddRange(installedPackages.Select(c => new DGMLLink {
SourceName = project.GetCustomUniqueName(), DestName = c.GetFullName(), Category = Resources.Visualizer_InstalledPackage
}));
}
}
private static InstalledProvider CreateInstalledProvider(
IVsPackageManager packageManager = null,
IProjectManager projectManager = null,
Project project = null,
IScriptExecutor scriptExecutor = null)
{
if (packageManager == null)
{
packageManager = new Mock <IVsPackageManager>().Object;
}
if (projectManager == null)
{
projectManager = new Mock <IProjectManager>().Object;
}
var mockProgressWindowOpener = new Mock <IProgressWindowOpener>();
if (project == null)
{
project = new Mock <Project>().Object;
}
if (scriptExecutor == null)
{
scriptExecutor = new Mock <IScriptExecutor>().Object;
}
var services = new ProviderServices(
null,
mockProgressWindowOpener.Object,
scriptExecutor,
new MockOutputConsoleProvider()
);
return(new InstalledProvider(packageManager, project, projectManager, new System.Windows.ResourceDictionary(), services, new Mock <IProgressProvider>().Object));
}
protected override bool ExecuteCore(PackageItem item)
{
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
using (activePackageManager.SourceRepository.StartOperation(OperationName, item.Id, item.Version))
{
ShowProgressWindow();
IList <PackageOperation> operations;
bool acceptLicense;
if (_project.SupportsINuGetProjectSystem())
{
operations = new List <PackageOperation>();
operations.Add(new PackageOperation(item.PackageIdentity, PackageAction.Install));
acceptLicense = ShowLicenseAgreement(activePackageManager, operations);
}
else
{
acceptLicense = ShowLicenseAgreement(
item.PackageIdentity,
activePackageManager,
_project.GetTargetFrameworkName(),
out operations);
}
if (!acceptLicense)
{
return(false);
}
ExecuteCommandOnProject(_project, item, activePackageManager, operations);
return(true);
}
}
private static InstalledProvider CreateInstalledProvider(
IVsPackageManager packageManager = null,
IProjectManager projectManager = null,
Project project = null,
IScriptExecutor scriptExecutor = null)
{
if (packageManager == null) {
packageManager = new Mock<IVsPackageManager>().Object;
}
if (projectManager == null) {
projectManager = new Mock<IProjectManager>().Object;
}
var mockProgressWindowOpener = new Mock<IProgressWindowOpener>();
if (project == null) {
project = new Mock<Project>().Object;
}
if (scriptExecutor == null) {
scriptExecutor = new Mock<IScriptExecutor>().Object;
}
var services = new ProviderServices(
null,
mockProgressWindowOpener.Object,
scriptExecutor,
new MockOutputConsoleProvider()
);
return new InstalledProvider(packageManager, project, projectManager, new System.Windows.ResourceDictionary(), services, new Mock<IProgressProvider>().Object);
}
protected void ExecuteCommandOnProject(Project activeProject, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
{
IProjectManager projectManager = null;
try
{
projectManager = activePackageManager.GetProjectManager(activeProject);
RegisterPackageOperationEvents(activePackageManager, projectManager);
ExecuteCommand(projectManager, item, activePackageManager, operations);
}
finally
{
if (projectManager != null)
{
UnregisterPackageOperationEvents(activePackageManager, projectManager);
}
}
}
protected override bool ExecuteCore(PackageItem item)
{
_activePackageManager = GetActivePackageManager();
using (_activePackageManager.SourceRepository.StartOperation(RepositoryOperationNames.Install, item.Id, item.Version))
{
IList<Project> selectedProjectsList;
ShowProgressWindow();
bool isProjectLevel = _activePackageManager.IsProjectLevel(item.PackageIdentity);
if (isProjectLevel)
{
HideProgressWindow();
var selectedProjects = _userNotifierServices.ShowProjectSelectorWindow(
Resources.Dialog_OnlineSolutionInstruction,
item.PackageIdentity,
DetermineProjectCheckState,
ignored => true);
if (selectedProjects == null)
{
// user presses Cancel button on the Solution dialog
return false;
}
selectedProjectsList = selectedProjects.ToList();
if (selectedProjectsList.Count == 0)
{
return false;
}
// save the checked state of projects so that we can restore them the next time
SaveProjectCheckStates(selectedProjectsList);
ShowProgressWindow();
}
else
{
// solution package. just install into the solution
selectedProjectsList = new Project[0];
}
IList<PackageOperation> operations;
bool acceptLicense = isProjectLevel ? ShowLicenseAgreement(item.PackageIdentity, _activePackageManager, selectedProjectsList, out operations)
: ShowLicenseAgreement(item.PackageIdentity, _activePackageManager, targetFramework: null, operations: out operations);
if (!acceptLicense)
{
return false;
}
try
{
RegisterPackageOperationEvents(_activePackageManager, null);
_activePackageManager.InstallPackage(
selectedProjectsList,
item.PackageIdentity,
operations,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
logger: this,
eventListener: this);
}
finally
{
UnregisterPackageOperationEvents(_activePackageManager, null);
}
return true;
}
}
private static InstalledProvider CreateInstalledProvider(
IVsPackageManager packageManager = null,
IPackageRepository localRepository = null,
Project project = null,
IScriptExecutor scriptExecutor = null,
ISolutionManager solutionManager = null,
IPackageRestoreManager packageRestoreManager = null)
{
if (packageManager == null)
{
packageManager = new Mock<IVsPackageManager>().Object;
}
var mockProgressWindowOpener = new Mock<IProgressWindowOpener>();
if (project == null)
{
project = new Mock<Project>().Object;
}
if (scriptExecutor == null)
{
scriptExecutor = new Mock<IScriptExecutor>().Object;
}
var services = new ProviderServices(
null,
mockProgressWindowOpener.Object,
new Mock<IProviderSettings>().Object,
new Mock<IUpdateAllUIService>().Object,
scriptExecutor,
new MockOutputConsoleProvider(),
new Mock<IVsCommonOperations>().Object
);
if (localRepository == null)
{
localRepository = new MockPackageRepository();
}
if (solutionManager == null)
{
solutionManager = new Mock<ISolutionManager>().Object;
}
if (packageRestoreManager == null)
{
packageRestoreManager = new Mock<IPackageRestoreManager>().Object;
}
return new InstalledProvider(
packageManager,
project,
localRepository,
new System.Windows.ResourceDictionary(),
services,
new Mock<IProgressProvider>().Object,
solutionManager,
packageRestoreManager);
}
protected virtual void ExecuteCommand(IProjectManager projectManager, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
{
activePackageManager.InstallPackage(projectManager, item.PackageIdentity, operations, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, logger: this);
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
FrameworkName targetFramework,
out IList<PackageOperation> operations)
{
var walker = new InstallWalker(
LocalRepository,
packageManager.SourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: packageManager.DependencyVersion);
operations = walker.ResolveOperations(package).ToList();
return ShowLicenseAgreement(packageManager, operations);
}
private void EnablePackageRestore(Project project, IVsPackageManager packageManager)
{
var projectManager = packageManager.GetProjectManager(project);
var projectPackageReferences = GetPackageReferences(projectManager);
if (projectPackageReferences.IsEmpty())
{
// don't enable package restore for the project if it doesn't have at least one
// nuget package installed
return;
}
EnablePackageRestore(project);
}
protected override void ExecuteCommand(IProjectManager projectManager, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
{
activePackageManager.UpdatePackages(
projectManager,
new [] { item.PackageIdentity },
operations,
updateDependencies: true,
allowPrereleaseVersions: IncludePrerelease,
logger: this);
}
public void OnAfterPackageOperation(IVsPackageManager packageManager)
{
}
protected bool ShowLicenseAgreement(IVsPackageManager packageManager, IEnumerable<PackageOperation> operations)
{
var licensePackages = from o in operations
where o.Action == PackageAction.Install &&
o.Package.RequireLicenseAcceptance &&
!packageManager.LocalRepository.Exists(o.Package)
select o.Package;
// display license window if necessary
if (licensePackages.Any())
{
// hide the progress window if we are going to show license window
HideProgressWindow();
bool accepted = _providerServices.UserNotifierServices.ShowLicenseWindow(licensePackages);
if (!accepted)
{
return false;
}
ShowProgressWindow();
}
return true;
}
public void OnBeforePackageOperation(IVsPackageManager packageManager)
{
}
protected override bool ExecuteCore(PackageItem item)
{
_activePackageManager = GetActivePackageManager();
using (_activePackageManager.SourceRepository.StartOperation(RepositoryOperationNames.Update))
{
ShowProgressWindow();
IList<Project> selectedProjectsList;
bool isProjectLevel = _activePackageManager.IsProjectLevel(item.PackageIdentity);
if (isProjectLevel)
{
HideProgressWindow();
var selectedProjects = _userNotifierServices.ShowProjectSelectorWindow(
Resources.Dialog_UpdatesSolutionInstruction,
item.PackageIdentity,
// Selector function to return the initial checkbox state for a Project.
// We check a project if it has the current package installed by Id, but not version
project => _activePackageManager.GetProjectManager(project).LocalRepository.Exists(item.Id),
project =>
{
var localRepository = _activePackageManager.GetProjectManager(project).LocalRepository;
// for the Updates solution dialog, we only enable a project if it has an old version of
// the package installed.
return localRepository.Exists(item.Id) &&
!localRepository.Exists(item.Id, item.PackageIdentity.Version);
}
);
if (selectedProjects == null)
{
// user presses Cancel button on the Solution dialog
return false;
}
selectedProjectsList = selectedProjects.ToList();
if (selectedProjectsList.Count == 0)
{
return false;
}
ShowProgressWindow();
}
else
{
// solution package. just update into the solution
selectedProjectsList = new Project[0];
}
IList<PackageOperation> operations;
bool acceptLicense = isProjectLevel ? ShowLicenseAgreement(item.PackageIdentity, _activePackageManager, selectedProjectsList, out operations)
: ShowLicenseAgreement(item.PackageIdentity, _activePackageManager, targetFramework: null, operations: out operations);
if (!acceptLicense)
{
return false;
}
if (!isProjectLevel && operations.Any())
{
// When dealing with solution level packages, only the set of actions specified under operations are executed.
// In such a case, no operation to uninstall the current package is specified. We'll identify the package that is being updated and
// explicitly add a uninstall operation.
var packageToUpdate = _activePackageManager.LocalRepository.FindPackage(item.Id);
if (packageToUpdate != null)
{
operations.Insert(0, new PackageOperation(packageToUpdate, PackageAction.Uninstall));
}
}
try
{
RegisterPackageOperationEvents(_activePackageManager, null);
_activePackageManager.UpdatePackage(
selectedProjectsList,
item.PackageIdentity,
operations,
updateDependencies: true,
allowPrereleaseVersions: IncludePrerelease,
logger: this,
eventListener: this);
}
finally
{
UnregisterPackageOperationEvents(_activePackageManager, null);
}
return true;
}
}
protected override bool ExecuteAllCore()
{
if (SelectedNode == null || SelectedNode.Extensions == null || SelectedNode.Extensions.Count == 0)
{
return false;
}
ShowProgressWindow();
_activePackageManager = GetActivePackageManager();
Debug.Assert(_activePackageManager != null);
IDisposable action = _activePackageManager.SourceRepository.StartOperation(OperationName);
try
{
bool accepted = ShowLicenseAgreementForAllPackages(_activePackageManager);
if (!accepted)
{
return false;
}
RegisterPackageOperationEvents(_activePackageManager, null);
_activePackageManager.UpdatePackages(updateDependencies: true, allowPrereleaseVersions: IncludePrerelease, logger: this, eventListener: this);
return true;
}
finally
{
UnregisterPackageOperationEvents(_activePackageManager, null);
action.Dispose();
}
}
protected override bool ExecuteCore(PackageItem item)
{
_activePackageManager = GetActivePackageManager();
using (_activePackageManager.SourceRepository.StartOperation(RepositoryOperationNames.Install, item.Id, item.Version))
{
IList<Project> selectedProjectsList;
ShowProgressWindow();
bool isProjectLevel = _activePackageManager.IsProjectLevel(item.PackageIdentity);
if (isProjectLevel)
{
HideProgressWindow();
var selectedProjects = _userNotifierServices.ShowProjectSelectorWindow(
Resources.Dialog_OnlineSolutionInstruction,
item.PackageIdentity,
DetermineProjectCheckState,
ignored => true);
if (selectedProjects == null)
{
// user presses Cancel button on the Solution dialog
return false;
}
selectedProjectsList = selectedProjects.ToList();
if (selectedProjectsList.Count == 0)
{
return false;
}
// save the checked state of projects so that we can restore them the next time
SaveProjectCheckStates(selectedProjectsList);
ShowProgressWindow();
}
else
{
// solution package. just install into the active project.
selectedProjectsList = new Project[] { _solutionManager.DefaultProject };
}
// resolve operations
var actions = ResolveActionsForInstall(
item.PackageIdentity,
_activePackageManager,
selectedProjectsList);
bool acceptLicense = ShowLicenseAgreement(actions);
if (!acceptLicense)
{
return false;
}
// execute operations
try
{
RegisterPackageOperationEvents(_activePackageManager, null);
var userOperationExecutor = new Resolver.ActionExecutor()
{
Logger = this,
PackageOperationEventListener = this
};
userOperationExecutor.Execute(actions);
}
finally
{
UnregisterPackageOperationEvents(_activePackageManager, null);
}
return true;
}
}
private static SolutionUpdatesProvider CreateSolutionUpdatesProvider(
IVsPackageManager packageManager = null,
IPackageRepository localRepository = null,
IPackageRepositoryFactory repositoryFactory = null,
IPackageSourceProvider packageSourceProvider = null,
IScriptExecutor scriptExecutor = null,
ISolutionManager solutionManager = null,
IUserNotifierServices userNotifierServices = null)
{
if (packageManager == null)
{
var packageManagerMock = new Mock<IVsPackageManager>();
var sourceRepository = new MockPackageRepository();
packageManagerMock.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager = packageManagerMock.Object;
}
if (repositoryFactory == null)
{
var repositoryFactoryMock = new Mock<IPackageRepositoryFactory>();
repositoryFactoryMock.Setup(p => p.CreateRepository(It.IsAny<string>())).Returns(new MockPackageRepository());
repositoryFactory = repositoryFactoryMock.Object;
}
if (packageSourceProvider == null)
{
var packageSourceProviderMock = new Mock<IPackageSourceProvider>();
packageSourceProviderMock.Setup(p => p.LoadPackageSources()).Returns(
new PackageSource[2] {
new PackageSource("Test1", "One"),
new PackageSource("Test2", "Two")
}
);
packageSourceProvider = packageSourceProviderMock.Object;
}
var factory = new Mock<IVsPackageManagerFactory>();
factory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(packageManager);
var mockProgressWindowOpener = new Mock<IProgressWindowOpener>();
if (userNotifierServices == null)
{
var mockWindowServices = new Mock<IUserNotifierServices>();
userNotifierServices = mockWindowServices.Object;
}
if (scriptExecutor == null)
{
scriptExecutor = new Mock<IScriptExecutor>().Object;
}
if (solutionManager == null)
{
solutionManager = new Mock<ISolutionManager>().Object;
}
if (userNotifierServices == null)
{
userNotifierServices = new Mock<IUserNotifierServices>().Object;
}
var services = new ProviderServices(
userNotifierServices,
mockProgressWindowOpener.Object,
new Mock<IProviderSettings>().Object,
new Mock<IUpdateAllUIService>().Object,
scriptExecutor,
new MockOutputConsoleProvider(),
new Mock<IVsCommonOperations>().Object
);
if (localRepository == null)
{
localRepository = new Mock<IPackageRepository>().Object;
}
return new SolutionUpdatesProvider(
localRepository,
new System.Windows.ResourceDictionary(),
repositoryFactory,
packageSourceProvider,
factory.Object,
services,
new Mock<IProgressProvider>().Object,
solutionManager);
}
private void InstallPackage(IVsPackageManager packageManager)
{
if (packageManager == null)
{
return;
}
packageManager.DependencyVersion = DependencyVersion;
packageManager.WhatIf = WhatIf;
packageManager.InstallPackage(ProjectManager, Id, Version, IgnoreDependencies, IncludePrerelease.IsPresent, logger: this);
}
protected virtual void ExecuteCommand(PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
{
activePackageManager.InstallPackage(ProjectManager, item.PackageIdentity, operations, ignoreDependencies: false, logger: this);
}
/// <summary>
/// Gets all package references in all projects of the current solution plus package
/// references specified in the solution packages.config
/// </summary>
private IEnumerable<PackageReference> GetAllPackageReferences(IVsPackageManager packageManager)
{
IEnumerable<PackageReference> projectReferences = from project in _solutionManager.GetProjects()
from reference in GetPackageReferences(packageManager.GetProjectManager(project))
select reference;
var localRepository = packageManager.LocalRepository as SharedPackageRepository;
if (localRepository != null)
{
IEnumerable<PackageReference> solutionReferences = localRepository.PackageReferenceFile.GetPackageReferences();
return projectReferences.Concat(solutionReferences).Distinct();
}
return projectReferences.Distinct();
}
public MockPackagesProvider(IPackageRepository localRepository, IVsPackageManager packageManagerr)
: this(localRepository, packageManagerr, Enumerable.Empty<string>())
{
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder)
{
allOperations = new List<PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
if (_project.SupportsINuGetProjectSystem())
{
packagesByDependencyOrder = allPackages.ToList();
foreach (var package in allPackages)
{
allOperations.Add(new PackageOperation(package, PackageAction.Install));
}
}
else
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: activePackageManager.DependencyVersion);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
}
return ShowLicenseAgreement(activePackageManager, allOperations);
}
private IEnumerable<Resolver.PackageAction> ResolveActionsForUpdateAll(IVsPackageManager activePackageManager, IProjectManager projectManager)
{
var resolver = new ActionResolver()
{
Logger = this,
AllowPrereleaseVersions = IncludePrerelease,
DependencyVersion = activePackageManager.DependencyVersion
};
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
foreach (var package in allPackages)
{
resolver.AddOperation(PackageAction.Install, package, projectManager);
}
var actions = resolver.ResolveActions();
return actions;
}
protected bool CheckPSScriptAndShowLicenseAgreement(
PackageItem item, IList<Project> projects, IVsPackageManager packageManager, out IList<PackageOperation> operations)
{
ShowProgressWindow();
// combine the operations of all selected project
var allOperations = new List<PackageOperation>();
foreach (Project project in projects)
{
IProjectManager projectManager = packageManager.GetProjectManager(project);
IList<PackageOperation> projectOperations;
CheckInstallPSScripts(
item.PackageIdentity,
projectManager.LocalRepository,
packageManager.SourceRepository,
project.GetTargetFrameworkName(),
IncludePrerelease,
out projectOperations);
allOperations.AddRange(projectOperations);
}
// reduce the operations before checking for license agreements
operations = allOperations.Reduce();
return ShowLicenseAgreement(packageManager, operations);
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
IEnumerable<Project> projects,
out IList<PackageOperation> operations)
{
var allOperations = new List<PackageOperation>();
foreach (Project project in projects)
{
var walker = new InstallWalker(
packageManager.GetProjectManager(project).LocalRepository,
packageManager.SourceRepository,
project.GetTargetFrameworkName(),
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: packageManager.DependencyVersion);
allOperations.AddRange(walker.ResolveOperations(package));
}
operations = allOperations.Reduce();
return ShowLicenseAgreement(packageManager, operations);
}
