public IEnumerable <PackageOperation> ResolveOperations(IPackage package)
{
// The cases when we don't check downgrade is when this object is
// called to restore packages, e.g. by nuget.exe restore command.
// Otherwise, check downgrade is true, e.g. when user installs a package
// inside VS.
if (CheckDowngrade)
{
//Check if the package is installed. This is necessary to know if this is a fresh-install or a downgrade operation
IPackage packageUnderInstallation = Repository.FindPackage(package.Id);
if (packageUnderInstallation != null && packageUnderInstallation.Version > package.Version)
{
_isDowngrade = true;
}
}
else
{
_isDowngrade = false;
}
_operations.Clear();
Marker.Clear();
_packagesToKeep.Clear();
Walk(package);
return(Operations.Reduce());
}
public IEnumerable <PackageOperation> ResolveOperations(IPackage package)
{
Operations.Clear();
Marker.Clear();
Walk(package);
// Log warnings for packages that were forcibly removed
foreach (var pair in _forcedRemoved)
{
Logger.Log(MessageLevel.Warning, NuGetResources.Warning_UninstallingPackageWillBreakDependents,
pair.Key,
String.Join(", ", pair.Value.Select(p => p.GetFullName())));
}
// Log warnings for dependencies that were skipped
foreach (var pair in _skippedPackages)
{
Logger.Log(MessageLevel.Warning, NuGetResources.Warning_PackageSkippedBecauseItIsInUse,
pair.Key,
String.Join(", ", pair.Value.Select(p => p.GetFullName())));
}
return(Operations.Reduce());
}
public IEnumerable <PackageOperation> ResolveOperations(IPackage package)
{
_operations.Clear();
Marker.Clear();
Walk(package);
return(Operations.Reduce());
}
/// <summary>
/// Get all packages from the specified repository in the dependency order,
/// e.g. if A -> B, then B will come before A.
/// </summary>
public IEnumerable <IPackage> GetPackagesByDependencyOrder(IPackageRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
Marker.Clear();
_repository = repository;
_sortedPackages = new List <IPackage>();
foreach (var package in _repository.GetPackages())
{
Walk(package);
}
return(_sortedPackages);
}
public IList <PackageOperation> ResolveOperations(IEnumerable <IPackage> packages, out IList <IPackage> packagesByDependencyOrder, bool allowPrereleaseVersionsBasedOnPackage = false)
{
_packagesByDependencyOrder = new Dictionary <string, IList <IPackage> >();
_operations.Clear();
Marker.Clear();
_packagesToKeep.Clear();
Debug.Assert(Operations is List <PackageOperation>);
foreach (var package in packages)
{
if (!_operations.Contains(package, PackageAction.Install))
{
var allowPrereleaseVersions = _allowPrereleaseVersions;
try
{
if (allowPrereleaseVersionsBasedOnPackage)
{
// Update _allowPrereleaseVersions before walking a package if allowPrereleaseVersionsBasedOnPackage is set to true
// This is mainly used when bulk resolving operations for reinstalling packages
_allowPrereleaseVersions = _allowPrereleaseVersions || !package.IsReleaseVersion();
}
Walk(package);
}
finally
{
_allowPrereleaseVersions = allowPrereleaseVersions;
}
}
}
// Flatten the dictionary to create a list of all the packages. Only this item the packages visited first during the walk will appear on the list. Also, only retain distinct elements
IEnumerable <IPackage> allPackagesByDependencyOrder = _packagesByDependencyOrder.SelectMany(p => p.Value).Distinct();
// Only retain the packages for which the operations are being resolved for
packagesByDependencyOrder = allPackagesByDependencyOrder.Where(p => packages.Any(q => p.Id == q.Id && p.Version == q.Version)).ToList();
Debug.Assert(packagesByDependencyOrder.Count == packages.Count());
_packagesByDependencyOrder.Clear();
_packagesByDependencyOrder = null;
return(Operations.Reduce());
}
