protected override void CreateVersions()
{
_versions = new List <DisplayVersion>();
var installedDependency = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound)
.OrderByDescending(p => p.VersionRange.MinVersion)
.FirstOrDefault();
// installVersion is null if the package is not installed
var installedVersion = installedDependency?.VersionRange?.MinVersion;
var allVersions = _allPackageVersions.OrderByDescending(v => v);
var latestPrerelease = allVersions.FirstOrDefault(v => v.IsPrerelease);
var latestStableVersion = allVersions.FirstOrDefault(v => !v.IsPrerelease);
// Add lastest prerelease if neeeded
if (latestPrerelease != null &&
(latestStableVersion == null || latestPrerelease > latestStableVersion) &&
!latestPrerelease.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestPrerelease, Resources.Version_LatestPrerelease));
}
// Add latest stable if needed
if (latestStableVersion != null &&
!latestStableVersion.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestStableVersion, Resources.Version_LatestStable));
}
// add a separator
if (_versions.Count > 0)
{
_versions.Add(null);
}
foreach (var version in allVersions)
{
if (!version.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(version, string.Empty));
}
}
SelectVersion();
OnPropertyChanged(nameof(Versions));
}
private void UpdateInstalledVersion()
{
var installed = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id)).OrderByDescending(p => p.VersionRange?.MinVersion, VersionComparer.Default);
var dependency = installed.FirstOrDefault(package => package.VersionRange != null && package.VersionRange.HasLowerBound);
if (dependency != null)
{
InstalledVersion = dependency.VersionRange.MinVersion;
}
else
{
InstalledVersion = null;
}
}
private void UpdateInstalledVersion()
{
IOrderedEnumerable <PackageDependency> installed = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id)).OrderByDescending(p => p.VersionRange?.MinVersion, VersionComparer.Default);
PackageDependency dependency = installed.FirstOrDefault(package => package.VersionRange != null && package.VersionRange.HasLowerBound);
if (dependency != null)
{
if (dependency.Id == _searchResultPackage.Id && _searchResultPackage.InstalledVersion != null)
{
InstalledVersion = _searchResultPackage.InstalledVersion;
}
else
{
InstalledVersion = dependency.VersionRange.MinVersion;
}
InstalledVersionRange = dependency.VersionRange;
}
else
{
InstalledVersion = null;
}
}
protected override Task CreateVersionsAsync(CancellationToken cancellationToken)
{
// The value will be null if the server does not return any versions.
if (_allPackageVersions == null || _allPackageVersions.Count == 0)
{
return(Task.CompletedTask);
}
_versions = new List <DisplayVersion>();
var installedDependency = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound)
.OrderByDescending(p => p.VersionRange.MinVersion)
.FirstOrDefault();
// installVersion is null if the package is not installed
var installedVersion = installedDependency?.VersionRange?.MinVersion;
List <(NuGetVersion version, bool isDeprecated)> allVersions = _allPackageVersions?.OrderByDescending(v => v.version).ToList();
// null, if no version constraint defined in package.config
VersionRange allowedVersions = _projectVersionConstraints.Select(e => e.VersionRange).FirstOrDefault();
// null, if all versions are allowed to be install or update
var blockedVersions = new List <NuGetVersion>(allVersions.Count);
List <(NuGetVersion version, bool isDeprecated)> allVersionsAllowed;
if (allowedVersions == null)
{
allowedVersions = VersionRange.All;
allVersionsAllowed = allVersions;
}
else
{
allVersionsAllowed = allVersions.Where(v => allowedVersions.Satisfies(v.version)).ToList();
foreach ((NuGetVersion version, bool isDeprecated) in allVersions)
{
if (!allVersionsAllowed.Any(a => a.version.Version.Equals(version.Version)))
{
blockedVersions.Add(version);
}
}
}
var latestPrerelease = allVersionsAllowed.FirstOrDefault(v => v.version.IsPrerelease);
var latestStableVersion = allVersionsAllowed.FirstOrDefault(v => !v.version.IsPrerelease);
// Add latest prerelease if neeeded
if (latestPrerelease.version != null &&
(latestStableVersion.version == null || latestPrerelease.version > latestStableVersion.version) &&
!latestPrerelease.version.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestPrerelease.version, Resources.Version_LatestPrerelease, isDeprecated: latestPrerelease.isDeprecated));
}
// Add latest stable if needed
if (latestStableVersion.version != null &&
!latestStableVersion.version.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestStableVersion.version, Resources.Version_LatestStable, isDeprecated: latestStableVersion.isDeprecated));
}
// add a separator
if (_versions.Count > 0)
{
_versions.Add(null);
}
// first add all the available versions to be updated
foreach (var version in allVersionsAllowed)
{
var installed = version.version.Equals(installedVersion);
var autoReferenced = false;
if (installed && _projectVersionConstraints.Any(e => e.IsAutoReferenced && e.VersionRange?.Satisfies(version.version) == true))
{
// do not allow auto referenced packages
autoReferenced = true;
}
_versions.Add(new DisplayVersion(version.version, additionalInfo: string.Empty, isCurrentInstalled: installed, autoReferenced: autoReferenced, isDeprecated: version.isDeprecated));
}
// Disable controls if this is an auto referenced package.
SetAutoReferencedCheck(InstalledVersion);
// Add disabled versions
AddBlockedVersions(blockedVersions);
SelectVersion();
OnPropertyChanged(nameof(Versions));
return(Task.CompletedTask);
}
protected override void CreateVersions()
{
_versions = new List <DisplayVersion>();
var installedDependency = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound)
.OrderByDescending(p => p.VersionRange.MinVersion)
.FirstOrDefault();
// installVersion is null if the package is not installed
var installedVersion = installedDependency?.VersionRange?.MinVersion;
var allVersions = _allPackageVersions?.OrderByDescending(v => v).ToArray();
// allVersions is null if server doesn't return any versions.
if (allVersions == null)
{
return;
}
// null, if no version constraint defined in package.config
var allowedVersions = _projectVersionConstraints.Select(e => e.VersionRange).FirstOrDefault() ?? VersionRange.All;
var allVersionsAllowed = allVersions.Where(v => allowedVersions.Satisfies(v)).ToArray();
// null, if all versions are allowed to be install or update
var blockedVersions = allVersions.Where(v => !allVersionsAllowed.Any(allowed => allowed.Version.Equals(v.Version))).ToArray();
var latestPrerelease = allVersionsAllowed.FirstOrDefault(v => v.IsPrerelease);
var latestStableVersion = allVersionsAllowed.FirstOrDefault(v => !v.IsPrerelease);
// Add lastest prerelease if neeeded
if (latestPrerelease != null &&
(latestStableVersion == null || latestPrerelease > latestStableVersion) &&
!latestPrerelease.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestPrerelease, Resources.Version_LatestPrerelease));
}
// Add latest stable if needed
if (latestStableVersion != null &&
!latestStableVersion.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestStableVersion, Resources.Version_LatestStable));
}
// add a separator
if (_versions.Count > 0)
{
_versions.Add(null);
}
// first add all the available versions to be updated
foreach (var version in allVersionsAllowed)
{
var installed = version.Equals(installedVersion);
var autoReferenced = false;
if (installed && _projectVersionConstraints.Any(e => e.IsAutoReferenced && e.VersionRange?.Satisfies(version) == true))
{
// do not allow auto referenced packatges
autoReferenced = true;
}
_versions.Add(new DisplayVersion(version, additionalInfo: string.Empty, isCurrentInstalled: installed, autoReferenced: autoReferenced));
}
// Disable controls if this is an auto referenced package.
SetAutoReferencedCheck(InstalledVersion);
// Add disabled versions
AddBlockedVersions(blockedVersions);
SelectVersion();
OnPropertyChanged(nameof(Versions));
}
protected override Task CreateVersionsAsync(CancellationToken cancellationToken)
{
// The value will be null if the server does not return any versions.
if (_allPackageVersions == null || _allPackageVersions.Count == 0)
{
return(Task.CompletedTask);
}
Versions.Clear();
var installedDependency = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound)
.OrderByDescending(p => p.VersionRange.MinVersion)
.FirstOrDefault();
// installVersion is null if the package is not installed
var installedVersion = installedDependency?.VersionRange;
List <(NuGetVersion version, bool isDeprecated)> allVersions = _allPackageVersions?.OrderByDescending(v => v.version).ToList();
// null, if no version constraint defined in package.config
VersionRange allowedVersions = _projectVersionConstraints.Select(e => e.VersionRange).FirstOrDefault();
// null, if all versions are allowed to be install or update
var blockedVersions = new List <NuGetVersion>(allVersions.Count);
List <(NuGetVersion version, bool isDeprecated)> allVersionsAllowed;
if (allowedVersions == null)
{
allowedVersions = VersionRange.All;
allVersionsAllowed = allVersions;
}
else
{
allVersionsAllowed = allVersions.Where(v => allowedVersions.Satisfies(v.version)).ToList();
foreach ((NuGetVersion version, bool isDeprecated) in allVersions)
{
if (!allVersionsAllowed.Any(a => a.version.Version.Equals(version.Version)))
{
blockedVersions.Add(version);
}
}
}
var latestPrerelease = allVersionsAllowed.FirstOrDefault(v => v.version.IsPrerelease);
var latestStableVersion = allVersionsAllowed.FirstOrDefault(v => !v.version.IsPrerelease);
// Add installed version if the project is PackageReference
if (_nugetProjects.Any() && installedDependency != null && installedDependency.VersionRange != null && _nugetProjects.First().ProjectStyle.Equals(ProjectModel.ProjectStyle.PackageReference))
{
VersionRange installedVersionRange = VersionRange.Parse(installedDependency.VersionRange.OriginalString, true);
NuGetVersion bestVersion = installedVersionRange.FindBestMatch(allVersionsAllowed.Select(v => v.version));
var deprecationInfo = allVersionsAllowed.FirstOrDefault(v => v.version == bestVersion).isDeprecated;
DisplayVersion displayVersion = new DisplayVersion(installedVersionRange, bestVersion, additionalInfo: string.Empty, isDeprecated: deprecationInfo);
_versions.Add(displayVersion);
}
var isInstalledFloatingOrRange = installedVersion != null && installedVersion.IsFloating || (installedVersion?.OriginalString != null &&
(installedVersion.OriginalString.StartsWith("(", StringComparison.OrdinalIgnoreCase) || installedVersion.OriginalString.StartsWith("[", StringComparison.OrdinalIgnoreCase)));
// Add latest prerelease if neeeded
if (latestPrerelease.version != null &&
(latestStableVersion.version == null || latestPrerelease.version > latestStableVersion.version) &&
(isInstalledFloatingOrRange || !latestPrerelease.version.Equals(installedVersion?.MinVersion)))
{
VersionRange latestPrereleaseVersionRange = VersionRange.Parse(latestPrerelease.version.ToString(), allowFloating: false);
_versions.Add(new DisplayVersion(latestPrereleaseVersionRange, latestPrerelease.version, Resources.Version_LatestPrerelease, isDeprecated: latestPrerelease.isDeprecated));
}
// Add latest stable if needed
if (latestStableVersion.version != null &&
(isInstalledFloatingOrRange || !latestStableVersion.version.Equals(InstalledVersion)))
{
VersionRange latestStableVersionRange = VersionRange.Parse(latestStableVersion.version.ToString(), allowFloating: false);
_versions.Add(new DisplayVersion(latestStableVersionRange, latestStableVersion.version, Resources.Version_LatestStable, isDeprecated: latestStableVersion.isDeprecated));
}
// add a separator
if (_versions.Count > 0)
{
_versions.Add(null);
}
// first add all the available versions to be updated
foreach (var version in allVersionsAllowed)
{
var installed = version.version.Equals(InstalledVersion);
var autoReferenced = false;
if (installed && _projectVersionConstraints.Any(e => e.IsAutoReferenced && e.VersionRange?.Satisfies(version.version) == true))
{
// do not allow auto referenced packages
autoReferenced = true;
}
VersionRange versionRange = VersionRange.Parse(version.version.ToString(), allowFloating: false);
_versions.Add(new DisplayVersion(versionRange, version.version, additionalInfo: null, isCurrentInstalled: installed, autoReferenced: autoReferenced, isDeprecated: version.isDeprecated));
}
// Disable controls if this is an auto referenced package.
SetAutoReferencedCheck(InstalledVersion);
// Add disabled versions
AddBlockedVersions(blockedVersions);
var latestVersion = latestPrerelease.version > latestStableVersion.version ? latestPrerelease.version : latestStableVersion.version;
SelectVersion(latestVersion);
return(Task.CompletedTask);
}
protected override void CreateVersions()
{
_versions = new List <DisplayVersion>();
var installedDependency = InstalledPackageDependencies.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound)
.OrderByDescending(p => p.VersionRange.MinVersion)
.FirstOrDefault();
// installVersion is null if the package is not installed
var installedVersion = installedDependency?.VersionRange?.MinVersion;
var allVersions = _allPackageVersions.OrderByDescending(v => v).ToArray();
// null, if no version constraint defined in package.config
var allowedVersions = _projectVersionRangeDict.Select(kvp => kvp.Value).FirstOrDefault() ?? VersionRange.All;
var allVersionsAllowed = allVersions.Where(v => allowedVersions.Satisfies(v)).ToArray();
// null, if all versions are allowed to be install or update
var blockedVersions = allVersions.Where(v => !allVersionsAllowed.Any(allowed => allowed.Version.Equals(v.Version))).ToArray();
var latestPrerelease = allVersionsAllowed.FirstOrDefault(v => v.IsPrerelease);
var latestStableVersion = allVersionsAllowed.FirstOrDefault(v => !v.IsPrerelease);
// Add lastest prerelease if neeeded
if (latestPrerelease != null &&
(latestStableVersion == null || latestPrerelease > latestStableVersion) &&
!latestPrerelease.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestPrerelease, Resources.Version_LatestPrerelease));
}
// Add latest stable if needed
if (latestStableVersion != null &&
!latestStableVersion.Equals(installedVersion))
{
_versions.Add(new DisplayVersion(latestStableVersion, Resources.Version_LatestStable));
}
// add a separator
if (_versions.Count > 0)
{
_versions.Add(null);
}
// first add all the available versions to be updated
foreach (var version in allVersionsAllowed)
{
_versions.Add(new DisplayVersion(version, string.Empty, isCurrentInstalled: version.Equals(installedVersion)));
}
// add a separator
if (blockedVersions.Any())
{
if (_versions.Count > 0)
{
_versions.Add(null);
}
_versions.Add(new DisplayVersion(new VersionRange(new NuGetVersion("0.0.0")), Resources.Version_Blocked, false));
}
// add all the versions blocked because of version constraint in package.config
bool isBlockedVersionEnabled = Options.SelectedDependencyBehavior.Behavior == DependencyBehavior.Ignore;
foreach (var version in blockedVersions)
{
_versions.Add(new DisplayVersion(version, string.Empty, isBlockedVersionEnabled));
}
SelectVersion();
OnPropertyChanged(nameof(Versions));
}
