/// <summary>
/// Return the resolve package actions
/// </summary>
protected async Task <IEnumerable <Tuple <NuGetProject, NuGetProjectAction> > > GetActions(
INuGetUI uiService,
IEnumerable <NuGetProject> targets,
UserAction userAction,
bool removeDependencies,
bool forceRemove,
ResolutionContext resolutionContext,
INuGetProjectContext projectContext,
CancellationToken token)
{
List <Tuple <NuGetProject, NuGetProjectAction> > results = new List <Tuple <NuGetProject, NuGetProjectAction> >();
Debug.Assert(userAction.PackageId != null, "Package id can never be null in a User action");
if (userAction.Action == NuGetProjectActionType.Install)
{
Debug.Assert(userAction.PackageIdentity != null, "Package identity cannot be null when installing a package");
foreach (var target in targets)
{
IEnumerable <NuGetProjectAction> actions;
actions = await _packageManager.PreviewInstallPackageAsync(target, userAction.PackageIdentity,
resolutionContext, projectContext, uiService.ActiveSource, null, token);
results.AddRange(actions.Select(a => new Tuple <NuGetProject, NuGetProjectAction>(target, a)));
}
}
else
{
UninstallationContext uninstallationContext = new UninstallationContext(
removeDependencies: removeDependencies,
forceRemove: forceRemove);
foreach (var target in targets)
{
IEnumerable <NuGetProjectAction> actions;
if (userAction.PackageIdentity != null)
{
actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageIdentity, uninstallationContext, projectContext, token);
}
else
{
actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageId, uninstallationContext, projectContext, token);
}
results.AddRange(actions.Select(a => new Tuple <NuGetProject, NuGetProjectAction>(target, a)));
}
}
return(results);
}
protected async Task <IReadOnlyList <ResolvedAction> > GetActionsForUninstallAsync(IEnumerable <NuGetProject> targets,
string packageId,
INuGetProjectContext projectContext,
UninstallationContext uninstallationContext,
CancellationToken token)
{
List <ResolvedAction> results = new List <ResolvedAction>();
foreach (NuGetProject target in targets)
{
IEnumerable <PackageReference> oldInstalledPackages = await target.GetInstalledPackagesAsync(token);
if (oldInstalledPackages != null && oldInstalledPackages.Any(t => t.PackageIdentity.Id.Equals(packageId, StringComparison.InvariantCultureIgnoreCase)))
{
try
{
var actions = await _packageManager.PreviewUninstallPackageAsync(target, packageId, uninstallationContext, projectContext, token);
results.AddRange(actions.Select(a => new ResolvedAction(target, a)));
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw;
}
}
}
return(results);
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetUninstallActionsAsync(
string projectId,
PackageIdentity packageIdentity,
bool removeDependencies,
bool forceRemove,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectId);
Assumes.NotNull(packageIdentity);
Assumes.False(packageIdentity.HasVersion);
Assumes.NotNull(_state.SourceCacheContext);
Assumes.NotNull(_state.ResolvedActions);
Assumes.Null(_state.PackageIdentity);
cancellationToken.ThrowIfCancellationRequested();
return(await CatchAndRethrowExceptionAsync(async() =>
{
INuGetProjectContext projectContext = await ServiceLocator.GetInstanceAsync <INuGetProjectContext>();
(bool success, NuGetProject? project) = await TryGetNuGetProjectMatchingProjectIdAsync(projectId);
Assumes.True(success);
Assumes.NotNull(project);
var projectActions = new List <ProjectAction>();
var uninstallationContext = new UninstallationContext(removeDependencies, forceRemove);
NuGetPackageManager packageManager = await _sharedState.PackageManager.GetValueAsync(cancellationToken);
IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUninstallPackageAsync(
project,
packageIdentity.Id,
uninstallationContext,
projectContext,
cancellationToken);
foreach (NuGetProjectAction action in actions)
{
var resolvedAction = new ResolvedAction(project, action);
var projectAction = new ProjectAction(
CreateProjectActionId(),
projectId,
action.PackageIdentity,
action.NuGetProjectActionType,
implicitActions: null);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
public Task <IEnumerable <NuGetProjectAction> > PreviewUninstallPackageAsync(
NuGetProject nuGetProject,
string packageId,
UninstallationContext uninstallationContext,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
return(packageManager.PreviewUninstallPackageAsync(
nuGetProject,
packageId,
uninstallationContext,
nuGetProjectContext,
token
));
}
/// <summary>
/// Return the resolve package actions
/// </summary>
private async Task <IReadOnlyList <ResolvedAction> > GetActionsAsync(
INuGetUI uiService,
IEnumerable <NuGetProject> targets,
UserAction userAction,
bool removeDependencies,
bool forceRemove,
ResolutionContext resolutionContext,
INuGetProjectContext projectContext,
CancellationToken token)
{
var results = new List <ResolvedAction>();
Debug.Assert(userAction.PackageId != null, "Package id can never be null in a User action");
if (userAction.Action == NuGetProjectActionType.Install)
{
foreach (var target in targets)
{
var actions = await _packageManager.PreviewInstallPackageAsync(
target,
new PackageIdentity(userAction.PackageId, userAction.Version),
resolutionContext,
projectContext,
uiService.ActiveSources,
null,
token);
results.AddRange(actions.Select(a => new ResolvedAction(target, a)));
}
}
else
{
var uninstallationContext = new UninstallationContext(
removeDependencies: removeDependencies,
forceRemove: forceRemove);
foreach (var target in targets)
{
IEnumerable <NuGetProjectAction> actions;
actions = await _packageManager.PreviewUninstallPackageAsync(
target, userAction.PackageId, uninstallationContext, projectContext, token);
results.AddRange(actions.Select(a => new ResolvedAction(target, a)));
}
}
return(results);
}
private static async Task MainAsync(string[] args)
{
CustomNuGetLogger logger = new CustomNuGetLogger();
DefaultFrameworkNameProvider frameworkNameProvider = new DefaultFrameworkNameProvider();
string testAppFrameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
//string folderName = "netstandard1.1";
//NuGetFramework currentFramework = folderName == null
// ? NuGetFramework.AnyFramework
// : NuGetFramework.ParseFolder(folderName, frameworkNameProvider);
NuGetFramework currentFramework = testAppFrameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(testAppFrameworkName, frameworkNameProvider);
List <Lazy <INuGetResourceProvider> > resourceProviders = new List <Lazy <INuGetResourceProvider> >();
resourceProviders.AddRange(Repository.Provider.GetCoreV3());
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, resourceProviders);
//Console.WriteLine("Getting metadata resource...");
//PackageMetadataResource metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>();
//Console.WriteLine("Getting search resource...");
//PackageSearchResource searchResource = await sourceRepository.GetResourceAsync<PackageSearchResource>();
//Console.WriteLine("Getting auto complete resource...");
//AutoCompleteResource autoCompleteResource = await sourceRepository.GetResourceAsync<AutoCompleteResource>();
//Console.WriteLine("Getting dependency info resource...");
//DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync<DependencyInfoResource>();
//Console.WriteLine("Getting download resource...");
//DownloadResource downloadResource = await sourceRepository.GetResourceAsync<DownloadResource>();
//
//Console.WriteLine();
//Console.WriteLine("-----------------------------------------------------------------------------");
//Console.WriteLine();
//Console.WriteLine("Getting metadata...");
//IEnumerable<IPackageSearchMetadata> metadata = await metadataResource.GetMetadataAsync("Newtonsoft.Json", false, false, logger, CancellationToken.None);
//metadata.Dump();
//
//Console.WriteLine();
//Console.WriteLine("-----------------------------------------------------------------------------");
//Console.WriteLine();
//Console.WriteLine("Searching metadata...");
//SearchFilter searchFilter = new SearchFilter(false, null);
//metadata = await searchResource.SearchAsync("Newtonsoft.Json", searchFilter, 0, 10, logger, CancellationToken.None);
//metadata.Dump();
//
//Console.WriteLine();
//Console.WriteLine("-----------------------------------------------------------------------------");
//Console.WriteLine();
//Console.WriteLine("Resolving dependencies...");
//IEnumerable<RemoteSourceDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages("Newtonsoft.Json", logger, CancellationToken.None);
//dependencyInfo.Dump();
//
//Console.WriteLine();
//Console.WriteLine("-----------------------------------------------------------------------------");
//Console.WriteLine();
//Console.WriteLine("Resolving for target framework {0}...", currentFramework);
//IEnumerable<SourcePackageDependencyInfo> dependencyInfo2 = await dependencyInfoResource.ResolvePackages("Newtonsoft.Json", currentFramework, logger, CancellationToken.None);
//dependencyInfo2.Dump();
Console.WriteLine();
Console.WriteLine("-----------------------------------------------------------------------------");
Console.WriteLine();
Console.WriteLine("Installing for target framework {0}...", currentFramework);
string rootPath = "ProjectRoot";
string targetPath = Path.Combine(rootPath, "Packages");
if (!Directory.Exists(targetPath))
{
Directory.CreateDirectory(targetPath);
}
ISettings settings = new CustomNuGetSettings(rootPath);
PackageSourceProvider sourceProvider = new PackageSourceProvider(settings);
SourceRepositoryProvider repoProvider = new SourceRepositoryProvider(sourceProvider, resourceProviders);
CustomNuGetProject project = new CustomNuGetProject(targetPath, currentFramework);
CustomSolutionManager solutionManager = new CustomSolutionManager(rootPath, project);
NuGetPackageManager manager = new NuGetPackageManager(repoProvider, settings, solutionManager, new CustomDeleteManager());
bool allowPrereleaseVersions = true;
bool allowUnlisted = false;
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
allowPrereleaseVersions,
allowUnlisted,
VersionConstraints.ExactMajor);
UninstallationContext uninstallContext = new UninstallationContext(
true,
false);
INuGetProjectContext projectContext = new CustomNuGetProjectContext();
List <SourceRepository> sourceRepositories = new List <SourceRepository>();
sourceRepositories.Add(sourceRepository);
Console.WriteLine("Preview for package install...");
IEnumerable <NuGetProjectAction> installActions = await manager.PreviewInstallPackageAsync(
project,
new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 2)),
resolutionContext,
projectContext,
sourceRepositories,
Enumerable.Empty <SourceRepository>(),
CancellationToken.None);
Console.WriteLine("Execute package install...");
await manager.ExecuteNuGetProjectActionsAsync(
project,
installActions,
projectContext,
CancellationToken.None);
Console.WriteLine("Preview for package update...");
IEnumerable <NuGetProjectAction> updateActions = await manager.PreviewUpdatePackagesAsync(
new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 3)),
new[] { project },
resolutionContext,
projectContext,
sourceRepositories,
Enumerable.Empty <SourceRepository>(),
CancellationToken.None);
Console.WriteLine("Execute package update...");
await manager.ExecuteNuGetProjectActionsAsync(
project,
updateActions,
projectContext,
CancellationToken.None);
Console.WriteLine("Preview for package uninstall...");
IEnumerable <NuGetProjectAction> uninstallActions = await manager.PreviewUninstallPackageAsync(
project,
new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 3)),
uninstallContext,
projectContext,
CancellationToken.None);
Console.WriteLine("Execute package uninstall...");
await manager.ExecuteNuGetProjectActionsAsync(
project,
uninstallActions,
projectContext,
CancellationToken.None);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Done");
}
