public async Task GetPackagesWithUpdatesAsync_WithMultipleProjects_RetrievesNoUpdates()
{
// Arrange
var testPackageIdentity = new PackageCollectionItem("FakePackage", NuGetVersion.Parse("1.0.0"), installedReferences: null);
var serviceBroker = new Mock <IServiceBroker>();
Mock <INuGetProjectManagerService> projectManagerService = SetupProjectManagerService(serviceBroker);
IProjectContextInfo projectA = SetupProject(projectManagerService, "FakePackage", "2.0.1");
IProjectContextInfo projectB = SetupProject(projectManagerService, "FakePackage", "1.0.1", "[1,2)");
SetupRemotePackageMetadata("FakePackage", "0.0.1", "1.0.0", "2.0.1", "2.0.0", "1.0.1");
var _target = new UpdatePackageFeed(
serviceBroker.Object,
new[] { testPackageIdentity },
_metadataProvider,
new[] { projectA, projectB });
// Act
IEnumerable <IPackageSearchMetadata> packages = await _target.GetPackagesWithUpdatesAsync(
searchText : "fake",
new SearchFilter(includePrerelease : false),
CancellationToken.None);
// Assert
Assert.Empty(packages);
}
public PackageRestoreBar(INuGetSolutionManagerService solutionManager, IPackageRestoreManager packageRestoreManager, IProjectContextInfo projectContextInfo)
{
DataContext = this;
InitializeComponent();
_uiDispatcher = Dispatcher.CurrentDispatcher;
_solutionManager = solutionManager;
_packageRestoreManager = packageRestoreManager;
_projectContextInfo = projectContextInfo;
if (_packageRestoreManager != null)
{
_packageRestoreManager.PackagesMissingStatusChanged += OnPackagesMissingStatusChanged;
if (_projectContextInfo?.ProjectStyle == ProjectModel.ProjectStyle.PackageReference)
{
_packageRestoreManager.AssetsFileMissingStatusChanged += OnAssetsFileMissingStatusChanged;
}
}
// Set DynamicResource binding in code
// The reason we can't set it in XAML is that the VsBrushes class comes from either
// Microsoft.VisualStudio.Shell.10 or Microsoft.VisualStudio.Shell.11 assembly,
// depending on whether NuGet runs inside VS10 or VS11.
StatusMessage.SetResourceReference(TextBlock.ForegroundProperty, VsBrushes.InfoTextKey);
RestoreBar.SetResourceReference(Border.BackgroundProperty, VsBrushes.InfoBackgroundKey);
RestoreBar.SetResourceReference(Border.BorderBrushProperty, VsBrushes.ActiveBorderKey);
// Find storyboards that will be used to smoothly show and hide the restore bar.
_showRestoreBar = FindResource("ShowSmoothly") as Storyboard;
_hideRestoreBar = FindResource("HideSmoothly") as Storyboard;
}
public static async ValueTask <PackageInstallationInfo> CreateAsync(IProjectContextInfo project, CancellationToken cancellationToken)
{
var packageInstallationInfo = new PackageInstallationInfo(project);
await packageInstallationInfo.InitializeAsync(cancellationToken);
return(packageInstallationInfo);
}
public async ValueTask <IReadOnlyCollection <IProjectContextInfo> > GetUpgradeableProjectsAsync(
IReadOnlyCollection <string> projectIds,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
cancellationToken.ThrowIfCancellationRequested();
NuGetProject[] projects = await GetProjectsAsync(projectIds);
var upgradeableProjects = new List <IProjectContextInfo>();
IEnumerable <NuGetProject> capableProjects = projects
.Where(project =>
project.ProjectStyle == ProjectModel.ProjectStyle.PackagesConfig &&
project.ProjectServices.Capabilities.SupportsPackageReferences);
// get all packages.config based projects with no installed packages
foreach (NuGetProject project in capableProjects)
{
IEnumerable <PackageReference> installedPackages = await project.GetInstalledPackagesAsync(cancellationToken);
if (!installedPackages.Any())
{
IProjectContextInfo upgradeableProject = await ProjectContextInfo.CreateAsync(project, cancellationToken);
upgradeableProjects.Add(upgradeableProject);
}
}
return(upgradeableProjects);
}
public async Task UpgradeProjectsToPackageReferenceAsync(IEnumerable <IProjectContextInfo> msBuildProjects)
{
if (msBuildProjects == null)
{
throw new ArgumentNullException(nameof(msBuildProjects));
}
List <IProjectContextInfo> projects = Projects.ToList();
IServiceBroker serviceBroker = UIContext.ServiceBroker;
using (INuGetProjectUpgraderService projectUpgrader = await serviceBroker.GetProxyAsync <INuGetProjectUpgraderService>(
NuGetServices.ProjectUpgraderService,
cancellationToken: CancellationToken.None))
{
Assumes.NotNull(projectUpgrader);
foreach (IProjectContextInfo project in msBuildProjects)
{
IProjectContextInfo newProject = await projectUpgrader.UpgradeProjectToPackageReferenceAsync(
project.ProjectId,
CancellationToken.None);
if (newProject != null)
{
projects.Remove(project);
projects.Add(newProject);
}
}
}
Projects = projects;
}
private void ProjectChanged(object sender, IProjectContextInfo project)
{
_nugetProjects = new List <IProjectContextInfo> {
project
};
UpdateInstalledVersion();
}
public void SerializeThenDeserialize_WithValidArguments_RoundTrips(IProjectContextInfo expectedResult)
{
IProjectContextInfo actualResult = SerializeThenDeserialize(IProjectContextInfoFormatter.Instance, expectedResult);
Assert.Equal(expectedResult.ProjectId, actualResult.ProjectId);
Assert.Equal(expectedResult.ProjectStyle, actualResult.ProjectStyle);
Assert.Equal(expectedResult.ProjectKind, actualResult.ProjectKind);
}
public static async ValueTask <string?> GetUniqueNameOrNameAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
IProjectMetadataContextInfo metadata = await GetMetadataAsync(projectContextInfo, serviceBroker, cancellationToken);
return(metadata.UniqueName ?? metadata.Name);
}
private void OnMigrationLinkClick(object sender, RoutedEventArgs e)
{
IProjectContextInfo project = _model.Context.Projects.FirstOrDefault();
Debug.Assert(project != null);
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await _model.Context.UIActionEngine.UpgradeNuGetProjectAsync(_model.UIController, project);
})
.PostOnFailure(nameof(PRMigratorBar), nameof(OnMigrationLinkClick));
}
private PackageManagerControl GetProjectPackageManagerControl(string projectUniqueName)
{
return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var uiShell = ServiceLocator.GetGlobalService <SVsUIShell, IVsUIShell>();
foreach (var windowFrame in VsUtility.GetDocumentWindows(uiShell))
{
object docView;
var hr = windowFrame.GetProperty(
(int)__VSFPROPID.VSFPROPID_DocView,
out docView);
if (hr == VSConstants.S_OK &&
docView is PackageManagerWindowPane)
{
var packageManagerWindowPane = (PackageManagerWindowPane)docView;
if (packageManagerWindowPane.Model.IsSolution)
{
// the window is the solution package manager
continue;
}
var projects = packageManagerWindowPane.Model.Context.Projects;
if (projects.Count() != 1)
{
continue;
}
IProjectContextInfo existingProject = projects.First();
IServiceBroker serviceBroker = packageManagerWindowPane.Model.Context.ServiceBroker;
IProjectMetadataContextInfo projectMetadata = await existingProject.GetMetadataAsync(
serviceBroker,
CancellationToken.None);
if (string.Equals(projectMetadata.Name, projectUniqueName, StringComparison.OrdinalIgnoreCase))
{
var packageManagerControl = VsUtility.GetPackageManagerControl(windowFrame);
if (packageManagerControl != null)
{
return packageManagerControl;
}
}
}
}
return null;
}));
}
public static async ValueTask <IInstalledAndTransitivePackages> GetInstalledAndTransitivePackagesAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
Assumes.NotNull(projectContextInfo);
Assumes.NotNull(serviceBroker);
cancellationToken.ThrowIfCancellationRequested();
using (INuGetProjectManagerService projectManager = await GetProjectManagerAsync(serviceBroker, cancellationToken))
{
return(await projectManager.GetInstalledAndTransitivePackagesAsync(new string[] { projectContextInfo.ProjectId }, cancellationToken));
}
}
public static async ValueTask <IReadOnlyCollection <NuGetFramework> > GetTargetFrameworksAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
Assumes.NotNull(projectContextInfo);
Assumes.NotNull(serviceBroker);
cancellationToken.ThrowIfCancellationRequested();
using (INuGetProjectManagerService projectManager = await GetProjectManagerAsync(serviceBroker, cancellationToken))
{
return(await projectManager.GetTargetFrameworksAsync(new string[] { projectContextInfo.ProjectId }, cancellationToken));
}
}
public static async ValueTask <IProjectMetadataContextInfo> GetMetadataAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
Assumes.NotNull(projectContextInfo);
Assumes.NotNull(serviceBroker);
cancellationToken.ThrowIfCancellationRequested();
using (INuGetProjectManagerService projectManager = await GetProjectManagerAsync(serviceBroker, cancellationToken))
{
return(await projectManager.GetMetadataAsync(projectContextInfo.ProjectId, cancellationToken));
}
}
public async Task GetPackagesWithUpdatesAsync_WithHttpCache_RetrievesUpdate()
{
// Arrange
var testPackageIdentity = new PackageCollectionItem("FakePackage", new NuGetVersion("1.0.0"), null);
var serviceBroker = new Mock <IServiceBroker>();
Mock <INuGetProjectManagerService> projectManagerService = SetupProjectManagerService(serviceBroker);
IProjectContextInfo projectA = SetupProject(projectManagerService, "FakePackage", "1.0.0");
SetupRemotePackageMetadata("FakePackage", "0.0.1", "1.0.0", "2.0.0");
var _target = new UpdatePackageFeed(
serviceBroker.Object,
new[] { testPackageIdentity },
_metadataProvider,
new[] { projectA },
optionalCachedUpdates: null,
NullLogger.Instance);
// Act
IEnumerable <IPackageSearchMetadata> packages = await _target.GetPackagesWithUpdatesAsync(
searchText : "fake",
new SearchFilter(includePrerelease : false),
CancellationToken.None);
Assert.Single(packages);
IPackageSearchMetadata updateCandidate = packages.Single();
Assert.Equal("2.0.0", updateCandidate.Identity.Version.ToString());
SetupRemotePackageMetadata("FakePackage", "0.0.1", "1.0.0", "2.0.1", "2.0.0", "1.0.1");
packages = await _target.GetPackagesWithUpdatesAsync(
searchText : "fake",
new SearchFilter(includePrerelease : false),
CancellationToken.None);
Assert.Single(packages);
updateCandidate = packages.Single();
Assert.Equal("2.0.1", updateCandidate.Identity.Version.ToString());
IEnumerable <VersionInfo> actualVersions = await updateCandidate.GetVersionsAsync();
Assert.NotEmpty(actualVersions);
Assert.Equal(
new[] { "2.0.1", "2.0.0", "1.0.1", "1.0.0", "0.0.1" },
actualVersions.Select(v => v.Version.ToString()).ToArray());
}
private async Task <IVsWindowFrame> FindExistingWindowFrameAsync(Project project)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
foreach (var windowFrame in VsUtility.GetDocumentWindows(uiShell))
{
object docView;
var hr = windowFrame.GetProperty(
(int)__VSFPROPID.VSFPROPID_DocView,
out docView);
if (hr == VSConstants.S_OK &&
docView is PackageManagerWindowPane)
{
var packageManagerWindowPane = (PackageManagerWindowPane)docView;
if (packageManagerWindowPane.Model.IsSolution)
{
// the window is the solution package manager
continue;
}
var projects = packageManagerWindowPane.Model.Context.Projects;
if (projects.Count() != 1)
{
continue;
}
IProjectContextInfo existingProject = projects.First();
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
IProjectMetadataContextInfo projectMetadata = await existingProject.GetMetadataAsync(
serviceBroker,
CancellationToken.None);
if (string.Equals(projectMetadata.Name, project.Name, StringComparison.OrdinalIgnoreCase))
{
return(windowFrame);
}
}
}
return(null);
}
private void OnProjectEvent(
EventHandler <IProjectContextInfo>?eventHandler,
string memberName,
object sender,
NuGetProjectEventArgs e)
{
if (eventHandler != null)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
IProjectContextInfo project = await ProjectContextInfo.CreateAsync(
e.NuGetProject,
CancellationToken.None);
eventHandler(sender, project);
})
.PostOnFailure(nameof(NuGetSolutionManagerService), memberName);
}
}
public async Task GetPackagesWithUpdatesAsync_WithMultipleProjects_RetrievesSingleUpdate3()
{
// Arrange
var testPackageIdentity = new PackageCollectionItem("FakePackage", NuGetVersion.Parse("1.0.0"), null);
var serviceBroker = new Mock <IServiceBroker>();
Mock <INuGetProjectManagerService> projectManagerService = SetupProjectManagerService(serviceBroker);
// Only one project needs to be updated
// projectA: 2.0.1 => None
// projectB: 1.0.0 => 1.0.1
IProjectContextInfo projectA = SetupProject(projectManagerService, "FakePackage", "2.0.1");
IProjectContextInfo projectB = SetupProject(projectManagerService, "FakePackage", "1.0.0", "[1,2)");
SetupRemotePackageMetadata("FakePackage", "0.0.1", "1.0.0", "2.0.1", "2.0.0", "1.0.1");
var _target = new UpdatePackageFeed(
serviceBroker.Object,
new[] { testPackageIdentity },
_metadataProvider,
new[] { projectA, projectB },
optionalCachedUpdates: null,
NullLogger.Instance);
// Act
IEnumerable <IPackageSearchMetadata> packages = await _target.GetPackagesWithUpdatesAsync(
searchText : "fake",
new SearchFilter(includePrerelease : false),
CancellationToken.None);
// Assert
// Should retrieve a single update item with the lowest version and full list of available versions
Assert.Single(packages);
IPackageSearchMetadata updateCandidate = packages.Single();
Assert.Equal("1.0.1", updateCandidate.Identity.Version.ToString());
IEnumerable <VersionInfo> actualVersions = await updateCandidate.GetVersionsAsync();
Assert.NotEmpty(actualVersions);
Assert.Equal(
new[] { "2.0.1", "2.0.0", "1.0.1", "1.0.0", "0.0.1" },
actualVersions.Select(v => v.Version.ToString()).ToArray());
}
public static async ValueTask <bool> IsUpgradeableAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
Assumes.NotNull(projectContextInfo);
Assumes.NotNull(serviceBroker);
cancellationToken.ThrowIfCancellationRequested();
using (INuGetProjectUpgraderService? projectUpgrader = await serviceBroker.GetProxyAsync <INuGetProjectUpgraderService>(
NuGetServices.ProjectUpgraderService,
cancellationToken: cancellationToken))
{
Assumes.NotNull(projectUpgrader);
return(await projectUpgrader.IsProjectUpgradeableAsync(projectContextInfo.ProjectId, cancellationToken));
}
}
public static async ValueTask <(bool, string?)> TryGetInstalledPackageFilePathAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
PackageIdentity packageIdentity,
CancellationToken cancellationToken)
{
Assumes.NotNull(projectContextInfo);
Assumes.NotNull(serviceBroker);
Assumes.NotNull(packageIdentity);
cancellationToken.ThrowIfCancellationRequested();
using (INuGetProjectManagerService projectManager = await GetProjectManagerAsync(serviceBroker, cancellationToken))
{
return(await projectManager.TryGetInstalledPackageFilePathAsync(
projectContextInfo.ProjectId,
packageIdentity,
cancellationToken));
}
}
public static async ValueTask <IReadOnlyCollection <string> > GetPackageFoldersAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
if (projectContextInfo == null)
{
throw new ArgumentNullException(nameof(projectContextInfo));
}
if (serviceBroker == null)
{
throw new ArgumentNullException(nameof(serviceBroker));
}
cancellationToken.ThrowIfCancellationRequested();
using INuGetProjectManagerService projectManager = await GetProjectManagerAsync(serviceBroker, cancellationToken);
return(await projectManager.GetPackageFoldersAsync(new string[] { projectContextInfo.ProjectId }, cancellationToken));
}
public async Task GetPackagesWithUpdatesAsync_WithMultiplePackages_SortedByPackageId()
{
// Arrange
var testPackageIdentity = new PackageCollectionItem("FakePackage", NuGetVersion.Parse("1.0.0"), null);
var testPackageIdentity2 = new PackageCollectionItem("AFakePackage", NuGetVersion.Parse("1.0.0"), null);
var testPackageIdentity3 = new PackageCollectionItem("ZFakePackage", NuGetVersion.Parse("1.0.0"), null);
var serviceBroker = new Mock <IServiceBroker>();
Mock <INuGetProjectManagerService> projectManagerService = SetupProjectManagerService(serviceBroker);
IProjectContextInfo projectA = SetupProject(projectManagerService, "FakePackage", "1.0.0");
IProjectContextInfo projectB = SetupProject(projectManagerService, "ZFakePackage", "1.0.0");
IProjectContextInfo projectC = SetupProject(projectManagerService, "AFakePackage", "1.0.0");
SetupRemotePackageMetadata("FakePackage", "0.0.1", "1.0.0", "2.0.1", "2.0.0", "1.0.1");
SetupRemotePackageMetadata("ZFakePackage", "0.0.1", "1.0.0", "4.0.0");
SetupRemotePackageMetadata("AFakePackage", "1.0.0", "3.0.1");
var _target = new UpdatePackageFeed(
serviceBroker.Object,
new[] { testPackageIdentity, testPackageIdentity2, testPackageIdentity3 },
_metadataProvider,
new[] { projectA, projectB, projectC },
optionalCachedUpdates: null,
NullLogger.Instance);
// Act
IEnumerable <IPackageSearchMetadata> packages = await _target.GetPackagesWithUpdatesAsync(
searchText : "fake",
new SearchFilter(includePrerelease : false),
CancellationToken.None);
IEnumerable <string> actualPackageIds = packages.Select(p => p.Identity.Id);
// Assert
var expectedPackageIdsSorted = new List <string>()
{
"AFakePackage", "FakePackage", "ZFakePackage"
};
Assert.Equal(expectedPackageIdsSorted, actualPackageIds); //Equal considers sort order of collections.
}
public static async Task <NuGetProjectUpgradeWindowModel> CreateAsync(
IServiceBroker serviceBroker,
IProjectContextInfo project,
IList <PackageDependencyInfo> packageDependencyInfos,
CancellationToken cancellationToken)
{
Assumes.NotNull(project);
Assumes.NotNull(packageDependencyInfos);
cancellationToken.ThrowIfCancellationRequested();
string projectName = await project.GetUniqueNameOrNameAsync(serviceBroker, CancellationToken.None);
string title = string.Format(CultureInfo.CurrentCulture, Resources.WindowTitle_NuGetMigrator, projectName);
var notFoundPackages = new HashSet <PackageIdentity>();
var hasIssues = false;
IEnumerable <NuGetProjectUpgradeDependencyItem> dependencyItems =
PackageGraphAnalysisUtilities.GetPackagesWithDependants(packageDependencyInfos)
.Select(e => new NuGetProjectUpgradeDependencyItem(e.Identity, e));
foreach (NuGetProjectUpgradeDependencyItem dependencyItem in dependencyItems)
{
(bool _, string packagePath) = await project.TryGetInstalledPackageFilePathAsync(
serviceBroker,
dependencyItem.Identity,
cancellationToken);
InitPackageUpgradeIssues(packagePath, dependencyItem, notFoundPackages, ref hasIssues);
}
var upgradeDependencyItems = new ObservableCollection <NuGetProjectUpgradeDependencyItem>(dependencyItems);
return(new NuGetProjectUpgradeWindowModel(
title,
upgradeDependencyItems,
notFoundPackages,
hasIssues));
}
private async Task ExecuteUpgradeNuGetProjectCommandAsync(object sender, EventArgs e)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (ShouldMEFBeInitialized())
{
await InitializeMEFAsync();
}
var project = VsMonitorSelection.GetActiveProject();
if (!await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(null, project))
{
MessageHelper.ShowWarningMessage(Resources.ProjectMigrateErrorMessage, Resources.ErrorDialogBoxTitle);
return;
}
string uniqueName = await project.GetCustomUniqueNameAsync();
// Close NuGet Package Manager if it is open for this project
IVsWindowFrame windowFrame = await FindExistingWindowFrameAsync(project);
windowFrame?.CloseFrame((uint)__FRAMECLOSE.FRAMECLOSE_SaveIfDirty);
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
NuGetProject nuGetProject = await SolutionManager.Value.GetNuGetProjectAsync(uniqueName);
IProjectContextInfo projectContextInfo = await ProjectContextInfo.CreateAsync(nuGetProject, CancellationToken.None);
using (INuGetUI uiController = await UIFactory.Value.CreateAsync(serviceBroker, projectContextInfo))
{
await uiController.UIContext.UIActionEngine.UpgradeNuGetProjectAsync(uiController, projectContextInfo);
uiController.UIContext.UserSettingsManager.PersistSettings();
}
}
internal void RaiseProjectUpdated(IProjectContextInfo project)
{
ProjectUpdated?.Invoke(this, project);
}
public async Task <bool> IsNuGetProjectUpgradeableAsync(IProjectContextInfo project, CancellationToken cancellationToken)
{
return(await project.IsUpgradeableAsync(ServiceBroker, cancellationToken));
}
private async ValueTask <IVsWindowFrame> CreateToolWindowAsync(WorkspaceVisualNodeBase workspaceVisualNodeBase, IVsHierarchy hier, uint itemId)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (!Guid.TryParse(IProjectContextInfoUtility.GetProjectGuidStringFromVslsQueryString(workspaceVisualNodeBase.VSSelectionMoniker), out Guid projectGuid))
{
throw new InvalidOperationException();
}
IVsWindowFrame windowFrame = null;
var uiShell = await _asyncServiceProvider.GetServiceAsync <SVsUIShell, IVsUIShell>();
Assumes.Present(uiShell);
uint toolWindowId;
bool foundToolWindowId = _projectGuidToToolWindowId.TryGetValue(projectGuid.ToString(), out toolWindowId);
const uint FTW_none = 0;
if (foundToolWindowId)
{
ErrorHandler.ThrowOnFailure(
uiShell.FindToolWindowEx(
FTW_none, //grfFTW - badly-documented enum value.
typeof(PackageManagerToolWindowPane).GUID, // rguidPersistenceSlot
toolWindowId, // dwToolWindowId
out windowFrame));
if (windowFrame != null)
{
((IVsWindowFrame2)windowFrame).ActivateOwnerDockedWindow();
}
else
{
_projectGuidToToolWindowId.Remove(projectGuid.ToString());
}
}
if (windowFrame == null)
{
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
IProjectContextInfo projectContextInfo = await IProjectContextInfoUtility.CreateAsync(serviceBroker, projectGuid.ToString(), CancellationToken.None);
INuGetUI uiController = await UIFactory.Value.CreateAsync(serviceBroker, projectContextInfo);
// This model takes ownership of --- and Dispose() responsibility for --- the INuGetUI instance.
var model = new PackageManagerModel(uiController, isSolution: false, editorFactoryGuid: GuidList.NuGetEditorType);
var control = await PackageManagerControl.CreateAsync(model, OutputConsoleLogger.Value);
var caption = string.Format(CultureInfo.CurrentCulture, Resx.Label_NuGetWindowCaption, Path.GetFileNameWithoutExtension(workspaceVisualNodeBase.NodeMoniker));
int[] pfDefaultPosition = null;
var windowPane = new PackageManagerToolWindowPane(control, projectGuid.ToString());
ErrorHandler.ThrowOnFailure(
uiShell.CreateToolWindow(
(uint)__VSCREATETOOLWIN.CTW_fInitNew,
++_maxToolWindowId, // dwToolWindowId
windowPane, // ToolWindowPane
Guid.Empty, // rclsidTool = GUID_NULL
typeof(PackageManagerToolWindowPane).GUID, // rguidPersistenceSlot
Guid.Empty, // reserved - do not use - GUID_NULL
null, // IServiceProvider
caption,
pfDefaultPosition,
out windowFrame));
_projectGuidToToolWindowId.Add(projectGuid.ToString(), _maxToolWindowId);
windowPane.Closed += WindowPane_Closed;
if (windowFrame != null)
{
WindowFrameHelper.AddF1HelpKeyword(windowFrame, keywordValue: F1KeywordValuePmUI);
WindowFrameHelper.DisableWindowAutoReopen(windowFrame);
WindowFrameHelper.DockToolWindow(windowFrame);
}
}
return(windowFrame);
}
public async Task UpgradeNuGetProjectAsync(INuGetUI uiService, IProjectContextInfo project)
{
Assumes.NotNull(uiService);
Assumes.NotNull(project);
INuGetUIContext context = uiService.UIContext;
// Restore the project before proceeding
string solutionDirectory = await context.SolutionManagerService.GetSolutionDirectoryAsync(CancellationToken.None);
await context.PackageRestoreManager.RestoreMissingPackagesInSolutionAsync(
solutionDirectory,
uiService.ProjectContext,
new LoggerAdapter(uiService.ProjectContext),
CancellationToken.None);
IServiceBroker serviceBroker = context.ServiceBroker;
NuGetProjectUpgradeWindowModel upgradeInformationWindowModel;
using (INuGetProjectManagerService projectManager = await serviceBroker.GetProxyAsync <INuGetProjectManagerService>(
NuGetServices.ProjectManagerService,
CancellationToken.None))
{
Assumes.NotNull(projectManager);
IReadOnlyCollection <PackageDependencyInfo> packagesDependencyInfo = await projectManager.GetInstalledPackagesDependencyInfoAsync(
project.ProjectId,
includeUnresolved : true,
CancellationToken.None);
upgradeInformationWindowModel = await NuGetProjectUpgradeWindowModel.CreateAsync(
serviceBroker,
project,
packagesDependencyInfo.ToList(),
CancellationToken.None);
}
var result = uiService.ShowNuGetUpgradeWindow(upgradeInformationWindowModel);
if (!result)
{
// raise upgrade telemetry event with Cancelled status
var packagesCount = upgradeInformationWindowModel.UpgradeDependencyItems.Count;
var upgradeTelemetryEvent = new UpgradeInformationTelemetryEvent();
IEnumerable <string> projectIds = await ProjectUtility.GetSortedProjectIdsAsync(
uiService.UIContext.ServiceBroker,
uiService.Projects,
CancellationToken.None);
upgradeTelemetryEvent.SetResult(
projectIds,
NuGetOperationStatus.Cancelled,
packagesCount);
TelemetryActivity.EmitTelemetryEvent(upgradeTelemetryEvent);
return;
}
var progressDialogData = new ProgressDialogData(Resources.NuGetUpgrade_WaitMessage);
string projectName = await project.GetUniqueNameOrNameAsync(
uiService.UIContext.ServiceBroker,
CancellationToken.None);
string backupPath;
var windowTitle = string.Format(
CultureInfo.CurrentCulture,
Resources.WindowTitle_NuGetMigrator,
projectName);
using (IModalProgressDialogSession progressDialogSession = await context.StartModalProgressDialogAsync(windowTitle, progressDialogData, uiService))
{
backupPath = await PackagesConfigToPackageReferenceMigrator.DoUpgradeAsync(
context,
uiService,
project,
upgradeInformationWindowModel.UpgradeDependencyItems,
upgradeInformationWindowModel.NotFoundPackages,
progressDialogSession.Progress,
progressDialogSession.UserCancellationToken);
}
if (!string.IsNullOrEmpty(backupPath))
{
string htmlLogFile = GenerateUpgradeReport(projectName, backupPath, upgradeInformationWindowModel);
Process process = null;
try
{
process = Process.Start(htmlLogFile);
}
catch { }
}
}
private void OnAfterProjectRenamed(object sender, IProjectContextInfo e)
{
AfterProjectRenamed?.Invoke(this, e);
}
private void OnProjectAdded(object sender, IProjectContextInfo e)
{
ProjectAdded?.Invoke(this, e);
}
internal static async Task <string> DoUpgradeAsync(
INuGetUIContext context,
INuGetUI uiService,
IProjectContextInfo project,
IEnumerable <NuGetProjectUpgradeDependencyItem> upgradeDependencyItems,
IEnumerable <PackageIdentity> notFoundPackages,
IProgress <ProgressDialogData> progress,
CancellationToken token)
{
var startTime = DateTimeOffset.Now;
var packagesCount = 0;
var status = NuGetOperationStatus.Succeeded;
var upgradeInformationTelemetryEvent = new UpgradeInformationTelemetryEvent();
using (var telemetry = TelemetryActivity.Create(upgradeInformationTelemetryEvent))
{
try
{
// 0. Fail if any package was not found
if (notFoundPackages.Any())
{
status = NuGetOperationStatus.Failed;
var notFoundPackageIds = string.Join(",", notFoundPackages.Select(t => t.Id));
uiService.ProjectContext.Log(MessageLevel.Error, string.Format(CultureInfo.CurrentCulture, Resources.Migrator_PackageNotFound, notFoundPackageIds));
return(null);
}
IServiceBroker serviceBroker = await BrokeredServicesUtilities.GetRemoteServiceBrokerAsync();
using (INuGetProjectUpgraderService projectUpgrader = await serviceBroker.GetProxyAsync <INuGetProjectUpgraderService>(
NuGetServices.ProjectUpgraderService,
token))
{
Assumes.NotNull(projectUpgrader);
string backupPath;
// 1. Backup files (csproj and packages.config) that will change
try
{
backupPath = await projectUpgrader.BackupProjectAsync(project.ProjectId, token);
}
catch (Exception ex)
{
status = NuGetOperationStatus.Failed;
uiService.ShowError(ex);
uiService.ProjectContext.Log(
MessageLevel.Info,
string.Format(CultureInfo.CurrentCulture, Resources.Upgrader_BackupFailed));
return(null);
}
// 2. Uninstall all packages currently in packages.config
var progressData = new ProgressDialogData(Resources.NuGetUpgrade_WaitMessage, Resources.NuGetUpgrade_Progress_Uninstalling);
progress.Report(progressData);
// Don't uninstall packages we couldn't find - that will just fail
PackageIdentity[] packagesToUninstall = upgradeDependencyItems.Select(d => d.Identity)
.Where(p => !notFoundPackages.Contains(p))
.ToArray();
try
{
await projectUpgrader.UninstallPackagesAsync(project.ProjectId, packagesToUninstall, token);
}
catch (Exception ex)
{
status = NuGetOperationStatus.Failed;
// log error message
uiService.ShowError(ex);
uiService.ProjectContext.Log(MessageLevel.Info,
string.Format(CultureInfo.CurrentCulture, Resources.Upgrade_UninstallFailed));
return(null);
}
// Reload the project, and get a reference to the reloaded project
await projectUpgrader.SaveProjectAsync(project.ProjectId, token);
IProjectContextInfo upgradedProject = await projectUpgrader.UpgradeProjectToPackageReferenceAsync(
project.ProjectId,
token);
// Ensure we use the updated project for installing, and don't display preview or license acceptance windows.
context.Projects = new[] { upgradedProject };
var nuGetUI = (NuGetUI)uiService;
nuGetUI.Projects = new[] { upgradedProject };
nuGetUI.DisplayPreviewWindow = false;
// 4. Install the requested packages
var ideExecutionContext = uiService.ProjectContext.ExecutionContext as IDEExecutionContext;
if (ideExecutionContext != null)
{
await ideExecutionContext.SaveExpandedNodeStates(context.SolutionManager);
}
progressData = new ProgressDialogData(Resources.NuGetUpgrade_WaitMessage, Resources.NuGetUpgrade_Progress_Installing);
progress.Report(progressData);
List <PackageIdentity> packagesToInstall = GetPackagesToInstall(upgradeDependencyItems).ToList();
packagesCount = packagesToInstall.Count;
try
{
await projectUpgrader.InstallPackagesAsync(
project.ProjectId,
packagesToInstall,
token);
if (ideExecutionContext != null)
{
await ideExecutionContext.CollapseAllNodes(context.SolutionManager);
}
return(backupPath);
}
catch (Exception ex)
{
status = NuGetOperationStatus.Failed;
uiService.ShowError(ex);
uiService.ProjectContext.Log(MessageLevel.Info,
string.Format(CultureInfo.CurrentCulture, Resources.Upgrade_InstallFailed, backupPath));
uiService.ProjectContext.Log(MessageLevel.Info,
string.Format(CultureInfo.CurrentCulture, Resources.Upgrade_RevertSteps, "https://aka.ms/nugetupgraderevertv1"));
return(null);
}
}
}
catch (Exception ex)
{
status = NuGetOperationStatus.Failed;
uiService.ShowError(ex);
return(null);
}
finally
{
IEnumerable <string> projectIds = await ProjectUtility.GetSortedProjectIdsAsync(uiService.Projects, token);
upgradeInformationTelemetryEvent.SetResult(projectIds, status, packagesCount);
}
}
}
