Task <bool> InstallPackageAsync(string packageId, string version, BuildIntegratedInstallationContext installationContext)
{
var packageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var versionRange = new VersionRange(packageIdentity.Version);
return(project.InstallPackageAsync(packageId, versionRange, context, installationContext, CancellationToken.None));
}
BuildIntegratedInstallationContext CreateInstallationContext(
LibraryIncludeFlags?includeType = null,
LibraryIncludeFlags?suppressParent = null)
{
var framework = NuGetFramework.Parse(project.Project.TargetFrameworkMoniker.ToString());
var frameworks = new NuGetFramework [] {
framework
};
var originalFrameworks = new Dictionary <NuGetFramework, string> ();
originalFrameworks [framework] = framework.GetShortFolderName();
var installationContext = new BuildIntegratedInstallationContext(
frameworks,
Enumerable.Empty <NuGetFramework> (),
originalFrameworks);
if (includeType.HasValue)
{
installationContext.IncludeType = includeType.Value;
}
if (suppressParent.HasValue)
{
installationContext.SuppressParent = suppressParent.Value;
}
return(installationContext);
}
public async override Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var packageIdentity = new PackageIdentity(packageId, range.MinVersion);
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
return(await AddConditionalPackageReference(packageIdentity, nuGetProjectContext, installationContext));
}
bool added = await Runtime.RunInMainThread(() => {
return(AddPackageReference(packageIdentity, nuGetProjectContext, installationContext));
});
if (added)
{
await SaveProject();
}
return(added);
}
public override async Task <Boolean> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var success = false;
await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// We don't adjust package reference metadata from UI
_project.AddOrUpdateLegacyCSProjPackage(
packageId,
range.MinVersion.ToNormalizedString(),
metadataElements: new string[0],
metadataValues: new string[0]);
success = true;
});
return(success);
}
public void AddConditionalPackageReference(
PackageIdentity packageIdentity,
INuGetProjectContext context,
BuildIntegratedInstallationContext installationContext)
{
this.packageIdentity = packageIdentity;
this.context = context;
this.installationContext = installationContext;
}
public BuildIntegratedProjectAction(NuGetProject project,
PackageIdentity packageIdentity,
NuGetProjectActionType nuGetProjectActionType,
LockFile originalLockFile,
RestoreResultPair restoreResultPair,
IReadOnlyList<SourceRepository> sources,
IReadOnlyList<NuGetProjectAction> originalActions,
BuildIntegratedInstallationContext installationContext)
: this(project, packageIdentity, nuGetProjectActionType, originalLockFile, restoreResultPair, sources, originalActions, installationContext, versionRange: null)
{
}
async Task <bool> AddConditionalPackageReference(
PackageIdentity packageIdentity,
INuGetProjectContext context,
BuildIntegratedInstallationContext installationContext)
{
using (var handler = new ConditionalPackageReferenceHandler()) {
handler.AddConditionalPackageReference(packageIdentity, context, installationContext);
await SaveProject();
}
return(true);
}
public override async Task <Boolean> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
return(await InstallPackageWithMetadataAsync(packageId,
range,
metadataElements : new string[0],
metadataValues : new string[0]));
}
public async Task InstallPackageAsync_AddsPackageReference()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(randomTestFolder);
var projectServices = new TestProjectSystemServices();
LibraryDependency actualDependency = null;
Mock.Get(projectServices.References)
.Setup(x => x.AddOrUpdatePackageReferenceAsync(
It.IsAny <LibraryDependency>(), CancellationToken.None))
.Callback <LibraryDependency, CancellationToken>((d, _) => actualDependency = d)
.Returns(Task.CompletedTask);
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var buildIntegratedInstallationContext = new BuildIntegratedInstallationContext(
Enumerable.Empty <NuGetFramework>(),
Enumerable.Empty <NuGetFramework>(),
new Dictionary <NuGetFramework, string>());
// Act
var result = await testProject.InstallPackageAsync(
"packageA",
VersionRange.Parse("1.*"),
null,
buildIntegratedInstallationContext,
CancellationToken.None);
// Assert
Assert.True(result);
Assert.NotNull(actualDependency);
Assert.Equal("packageA", actualDependency.LibraryRange.Name);
Assert.Equal(VersionRange.Parse("1.*"), actualDependency.LibraryRange.VersionRange);
// Verify
Mock.Get(projectServices.References)
.Verify(
x => x.AddOrUpdatePackageReferenceAsync(It.IsAny <LibraryDependency>(), CancellationToken.None),
Times.Once);
}
}
public BuildIntegratedProjectAction(NuGetProject project,
PackageIdentity packageIdentity,
NuGetProjectActionType nuGetProjectActionType,
LockFile originalLockFile,
RestoreResultPair restoreResultPair,
IReadOnlyList<SourceRepository> sources,
IReadOnlyList<NuGetProjectAction> originalActions,
BuildIntegratedInstallationContext installationContext,
VersionRange versionRange)
: base(packageIdentity, nuGetProjectActionType, project, sourceRepository: null, versionRange)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (originalLockFile == null)
{
throw new ArgumentNullException(nameof(originalLockFile));
}
if (restoreResultPair == null)
{
throw new ArgumentNullException(nameof(restoreResultPair));
}
if (sources == null)
{
throw new ArgumentNullException(nameof(sources));
}
if (originalActions == null)
{
throw new ArgumentNullException(nameof(sources));
}
if (installationContext == null)
{
throw new ArgumentNullException(nameof(sources));
}
OriginalLockFile = originalLockFile;
RestoreResult = restoreResultPair.Result;
RestoreResultPair = restoreResultPair;
Sources = sources;
OriginalActions = originalActions;
InstallationContext = installationContext;
}
public async Task InstallPackageAsync_MultiTargetPartialUpdate_PackageReferenceUpdated()
{
CreateNuGetProject();
FilePath projectDirectory = Util.CreateTmpDir("MultiTargetInstallTest");
dotNetProject.FileName = projectDirectory.Combine("MultiTargetTest.csproj");
project.CallBaseSaveProject = true;
var successfulFrameworks = new NuGetFramework [] {
NuGetFramework.Parse("net472"),
};
var unsuccessfulFrameworks = new NuGetFramework [] {
NuGetFramework.Parse("netstandard1.5")
};
var originalFrameworks = new Dictionary <NuGetFramework, string> ();
var installationContext = new BuildIntegratedInstallationContext(
successfulFrameworks,
unsuccessfulFrameworks,
originalFrameworks);
bool firstInstallResult = await InstallPackageAsync("TestPackage", "2.6.1", installationContext);
var packageReference = dotNetProject
.MSBuildProject
.GetAllItems()
.SingleOrDefault(item => item.Include == "TestPackage");
Assert.AreEqual("2.6.1", packageReference.Metadata.GetValue("Version"));
bool result = await InstallPackageAsync("TestPackage", "3.0.1", installationContext);
var updatedPackageReference = dotNetProject
.MSBuildProject
.GetAllItems()
.FirstOrDefault(item => item.Include == "TestPackage");
Assert.AreEqual("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
Assert.AreEqual("3.0.1", packageReference.Metadata.GetValue("Version"));
Assert.IsTrue(firstInstallResult);
Assert.AreEqual("'$(TargetFramework)' == 'net472'", updatedPackageReference.ParentGroup.Condition);
Assert.AreEqual("3.0.1", updatedPackageReference.Metadata.GetValue("Version"));
Assert.IsTrue(result);
Assert.IsTrue(project.IsSaved);
}
public async override Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var dependency = new PackageDependency(packageId, range);
var json = await GetJsonAsync();
JsonConfigUtility.AddDependency(json, dependency);
await SaveJsonAsync(json);
return(true);
}
public async Task InstallPackageAsync_MultiTargetPartialInstallPrivateAndIncludeAssets_PackageReferenceHasAssetInfo()
{
CreateNuGetProject();
FilePath projectDirectory = Util.CreateTmpDir("MultiTargetInstallTest");
dotNetProject.FileName = projectDirectory.Combine("MultiTargetTest.csproj");
project.CallBaseSaveProject = true;
var successfulFrameworks = new NuGetFramework [] {
NuGetFramework.Parse("net472"),
};
var unsuccessfulFrameworks = new NuGetFramework [] {
NuGetFramework.Parse("netstandard1.5")
};
var originalFrameworks = new Dictionary <NuGetFramework, string> ();
var installationContext = new BuildIntegratedInstallationContext(
successfulFrameworks,
unsuccessfulFrameworks,
originalFrameworks);
installationContext.IncludeType = LibraryIncludeFlags.Runtime |
LibraryIncludeFlags.Build |
LibraryIncludeFlags.Native |
LibraryIncludeFlags.ContentFiles |
LibraryIncludeFlags.Analyzers;
installationContext.SuppressParent = LibraryIncludeFlags.All;
bool result = await InstallPackageAsync("TestPackage", "2.6.1", installationContext);
var packageReference = dotNetProject
.MSBuildProject
.GetAllItems()
.SingleOrDefault(item => item.Include == "TestPackage");
Assert.AreEqual("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
Assert.AreEqual("2.6.1", packageReference.Metadata.GetValue("Version"));
Assert.AreEqual("runtime; build; native; contentfiles; analyzers", packageReference.Metadata.GetValue("IncludeAssets"));
Assert.AreEqual("all", packageReference.Metadata.GetValue("PrivateAssets"));
Assert.IsTrue(result);
Assert.IsTrue(project.IsSaved);
}
public override async Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext _,
BuildIntegratedInstallationContext __,
CancellationToken token)
{
var dependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageId,
versionRange: range,
typeConstraint: LibraryDependencyTarget.Package)
};
await ProjectServices.References.AddOrUpdatePackageReferenceAsync(dependency, token);
return(true);
}
public override Task <bool> InstallPackageAsync(string packageId, VersionRange range, INuGetProjectContext nuGetProjectContext, BuildIntegratedInstallationContext installationContext, CancellationToken token)
{
throw new NotImplementedException();
}
public abstract Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token);
public override async Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
// Right now, the UI only handles installation of specific versions, which is just the minimum version of
// the provided version range.
var formattedRange = range.MinVersion.ToNormalizedString();
nuGetProjectContext.Log(MessageLevel.Info, Strings.InstallingPackage, $"{packageId} {formattedRange}");
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
// This is the "partial install" case. That is, install the package to only a subset of the frameworks
// supported by this project.
var conditionalService = _unconfiguredProject
.Services
.ExportProvider
.GetExportedValue <IConditionalPackageReferencesService>();
if (conditionalService == null)
{
throw new InvalidOperationException(string.Format(
Strings.UnableToGetCPSPackageInstallationService,
_projectFullPath));
}
foreach (var framework in installationContext.SuccessfulFrameworks)
{
string originalFramework;
if (!installationContext.OriginalFrameworks.TryGetValue(framework, out originalFramework))
{
originalFramework = framework.GetShortFolderName();
}
await conditionalService.AddAsync(
packageId,
formattedRange,
TargetFrameworkCondition,
originalFramework);
}
}
else
{
// Install the package to all frameworks.
var configuredProject = await _unconfiguredProject.GetSuggestedConfiguredProjectAsync();
var result = await configuredProject?
.Services
.PackageReferences
.AddAsync(packageId, formattedRange);
// This is the update operation
if (result != null && !result.Added)
{
var existingReference = result.Reference;
await existingReference?.Metadata.SetPropertyValueAsync("Version", formattedRange);
}
}
return(true);
}
public override async Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var formattedRange = range.OriginalString ?? range.MinVersion.ToNormalizedString();
nuGetProjectContext.Log(MessageLevel.Info, Strings.InstallingPackage, $"{packageId} {formattedRange}");
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
// This is the "partial install" case. That is, install the package to only a subset of the frameworks
// supported by this project.
var conditionalService = _unconfiguredProject
.Services
.ExportProvider
.GetExportedValue <IConditionalPackageReferencesService>();
if (conditionalService == null)
{
throw new InvalidOperationException(string.Format(
Strings.UnableToGetCPSPackageInstallationService,
ProjectFullPath));
}
foreach (var framework in installationContext.SuccessfulFrameworks)
{
string originalFramework;
if (!installationContext.OriginalFrameworks.TryGetValue(framework, out originalFramework))
{
originalFramework = framework.GetShortFolderName();
}
var reference = await conditionalService.AddAsync(
packageId,
formattedRange,
TargetFrameworkCondition,
originalFramework);
// SuppressParent could be set to All if developmentDependency flag is true in package nuspec file.
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
await SetPackagePropertyValueAsync(
reference.Metadata,
ProjectItemProperties.PrivateAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
await SetPackagePropertyValueAsync(
reference.Metadata,
ProjectItemProperties.IncludeAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
}
}
else
{
// Install the package to all frameworks.
var configuredProject = await _unconfiguredProject.GetSuggestedConfiguredProjectAsync();
var result = await configuredProject
.Services
.PackageReferences
.AddAsync(packageId, formattedRange);
// This is the update operation
if (!result.Added)
{
var existingReference = result.Reference;
await existingReference.Metadata.SetPropertyValueAsync("Version", formattedRange);
}
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
await SetPackagePropertyValueAsync(
result.Reference.Metadata,
ProjectItemProperties.PrivateAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
await SetPackagePropertyValueAsync(
result.Reference.Metadata,
ProjectItemProperties.IncludeAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
}
return(true);
}
bool AddPackageReference(PackageIdentity packageIdentity, INuGetProjectContext context, BuildIntegratedInstallationContext installationContext)
{
ProjectPackageReference packageReference = project.GetPackageReference(packageIdentity, matchVersion: false);
if (packageReference?.Equals(packageIdentity, matchVersion: true) == true)
{
context.Log(MessageLevel.Warning, GettextCatalog.GetString("Package '{0}' already exists in project '{1}'", packageIdentity, project.Name));
return(false);
}
if (packageReference != null)
{
packageReference.Version = packageIdentity.Version.ToNormalizedString();
}
else
{
packageReference = ProjectPackageReference.Create(packageIdentity);
project.Items.Add(packageReference);
}
if (installationContext.IncludeType != LibraryIncludeFlags.All &&
installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
packageReference.SetMetadataValue(ProjectItemProperties.IncludeAssets, installationContext.IncludeType);
packageReference.SetMetadataValue(ProjectItemProperties.PrivateAssets, installationContext.SuppressParent);
}
return(true);
}
public override Task <bool> InstallPackageAsync(string packageId, VersionRange range, INuGetProjectContext nuGetProjectContext, BuildIntegratedInstallationContext installationContext, CancellationToken token)
{
var formattedRange = range.MinVersion.ToNormalizedString();
nuGetProjectContext.Log(MessageLevel.Info, "Installing {0}", $"{packageId} {formattedRange}");
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
foreach (var framework in installationContext.SuccessfulFrameworks)
{
if (!installationContext.OriginalFrameworks.TryGetValue(framework, out string originalFramework))
{
originalFramework = framework.GetShortFolderName();
}
var metadata = new Dictionary <string, string>();
// SuppressParent could be set to All if developmentDependency flag is true in package nuspec file.
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
metadata = new Dictionary <string, string> {
{ ProjectItemProperties.PrivateAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)) },
{ ProjectItemProperties.IncludeAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)) }
};
}
AddOrUpdatePackageReference(packageId, formattedRange, metadata, TargetFrameworkCondition, originalFramework);
}
}
else
{
// Install the package to all frameworks.
var metadata = new Dictionary <string, string>();
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
metadata.Add(ProjectItemProperties.PrivateAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
metadata.Add(ProjectItemProperties.IncludeAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
AddOrUpdatePackageReference(packageId, formattedRange, metadata, null, null);
}
return(Task.FromResult(true));
}
