public override Task <IEnumerable <NuGetVersion> > GetVersions(
string packageId,
bool includePrerelease,
bool includeUnlisted,
ILogger log,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
return(Task.Run <IEnumerable <NuGetVersion> >(() =>
{
try
{
return _localResource.FindPackagesById(packageId, log, token)
.Select(p => p.Identity.Version)
.Where(v => includePrerelease || !v.IsPrerelease)
.Distinct()
.ToArray();
}
catch (Exception ex)
{
throw new FatalProtocolException(string.Format(CultureInfo.CurrentCulture,
Strings.Protocol_PackageMetadataError,
packageId,
_localResource.Root),
ex);
}
}));
}
private static List <VersionInfo> GetVersions(
FindLocalPackagesResource localResource,
LocalPackageInfo package,
SearchFilter filter,
ILogger log,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
// apply the filters to the version list returned
var versions = localResource.FindPackagesById(package.Identity.Id, log, token)
.Where(v => filter.IncludePrerelease || !v.Identity.Version.IsPrerelease)
.Select(p => new VersionInfo(p.Identity.Version, downloadCount: 0))
.OrderByDescending(v => v.Version, VersionComparer.Default)
.ToList();
// Add in the current package if it does not already exist
if (!versions.Any(v => v.Version == package.Identity.Version))
{
var packageVersionInfo = new VersionInfo(package.Identity.Version, downloadCount: 0)
{
PackageSearchMetadata = new LocalPackageSearchMetadata(package)
};
versions.Add(packageVersionInfo);
}
return(versions);
}
protected async Task <IEnumerable <NuGetVersion> > GetPackageVersionsFromLocalPackageRepository(
string packageId,
string versionPrefix,
bool includePrerelease,
ILogger log,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
return(await Task.Run(() =>
{
var packages = _localResource.FindPackagesById(packageId, log, token);
if (!includePrerelease)
{
packages = packages.Where(p => !p.Identity.Version.IsPrerelease);
}
// Check both the non-normalized and full string versions
return packages.Where(p => p.Identity.Version.ToString()
.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase) ||
p.Identity.Version.ToFullString().StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))
.Select(p => p.Identity.Version)
.ToList();
},
token));
}
/// <summary>
/// Retrieve dependency info for a single package.
/// </summary>
/// <param name="packageId">package id</param>
/// <param name="projectFramework">project target framework. This is used for finding the dependency group</param>
/// <param name="token">cancellation token</param>
public override Task <IEnumerable <SourcePackageDependencyInfo> > ResolvePackages(
string packageId,
NuGetFramework projectFramework,
SourceCacheContext sourceCacheContext,
ILogger log,
CancellationToken token)
{
if (packageId == null)
{
throw new ArgumentNullException(nameof(packageId));
}
if (projectFramework == null)
{
throw new ArgumentNullException(nameof(projectFramework));
}
var results = new List <SourcePackageDependencyInfo>();
try
{
// Retrieve all packages
foreach (var package in _localResource.FindPackagesById(packageId, log, token))
{
// Convert to dependency info type
results.Add(CreateDependencyInfo(package, projectFramework));
}
}
catch (NuGetProtocolException)
{
throw;
}
catch (Exception ex)
{
// Wrap exceptions coming from the server with a user friendly message
var error = string.Format(
CultureInfo.CurrentUICulture,
Strings.Protocol_PackageMetadataError,
packageId,
_localResource.Root);
throw new FatalProtocolException(error, ex);
}
return(Task.FromResult <IEnumerable <SourcePackageDependencyInfo> >(results));
}
public override Task <IEnumerable <IPackageSearchMetadata> > GetMetadataAsync(
string packageId,
bool includePrerelease,
bool includeUnlisted,
ILogger log,
CancellationToken token)
{
// All packages are considered listed within a local repo
return(Task.Run <IEnumerable <IPackageSearchMetadata> >(() =>
{
return _localResource.FindPackagesById(packageId, log, token)
.Where(p => includePrerelease || !p.Identity.Version.IsPrerelease)
.Select(GetPackageMetadata)
.ToList();
},
token));
}