/// <summary>
/// Query nuget package list from nuget server. This implementation optimized for performance so doesn't iterate whole result
/// returned nuget server, so as soon as find "take" number of result packages then stop processing and return the result.
/// </summary>
/// <param name="searchTerm">The term we're searching for.</param>
/// <param name="filter">Filter for whether to include prerelease, delisted, supportedframework flags in query.</param>
/// <param name="skip">Skip how many items from beginning of list.</param>
/// <param name="take">Return how many items.</param>
/// <param name="log">Logger instance.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>List of package meta data.</returns>
public override async Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(string searchTerm, SearchFilter filter, int skip, int take, Common.ILogger log, CancellationToken cancellationToken)
{
IEnumerable <PackageSearchMetadata> searchResultMetadata;
var metadataCache = new MetadataReferenceCache();
if (_client != null && _searchEndpoints != null)
{
searchResultMetadata = await Search(
searchTerm,
filter,
skip,
take,
Common.NullLogger.Instance,
cancellationToken);
}
else
{
#pragma warning disable CS0618
var searchResultJsonObjects = await _rawSearchResource.Search(searchTerm, filter, skip, take, Common.NullLogger.Instance, cancellationToken);
#pragma warning restore CS0618
searchResultMetadata = searchResultJsonObjects
.Select(s => s.FromJToken <PackageSearchMetadata>());
}
var searchResults = searchResultMetadata
.Select(m => m.WithVersions(() => GetVersions(m, filter)))
.Select(m => metadataCache.GetObject((PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)m))
.ToArray();
return(searchResults);
}
public override async Task <IEnumerable <IPackageSearchMetadata> > GetMetadataAsync(string packageId, bool includePrerelease, bool includeUnlisted, Common.ILogger log, CancellationToken token)
{
var metadataCache = new MetadataReferenceCache();
var packages =
(await _regResource.GetPackageMetadata(packageId, includePrerelease, includeUnlisted, log, token))
.Select(ParseMetadata)
.Select(m => metadataCache.GetObject(m))
.ToArray();
return(packages);
}
public override async Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(string searchTerm, SearchFilter filter, int skip, int take, Common.ILogger log, CancellationToken cancellationToken)
{
var searchResultJsonObjects = await _rawSearchResource.Search(searchTerm, filter, skip, take, Common.NullLogger.Instance, cancellationToken);
var metadataCache = new MetadataReferenceCache();
var searchResults = searchResultJsonObjects
.Select(s => s.FromJToken <PackageSearchMetadata>())
.Select(m => m.WithVersions(() => GetVersions(m, filter)))
.Select(m => metadataCache.GetObject((PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)m))
.ToArray();
return(searchResults);
}
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> >(() =>
{
var metadataCache = new MetadataReferenceCache();
return _localResource.FindPackagesById(packageId, log, token)
.Where(p => includePrerelease || !p.Identity.Version.IsPrerelease)
.Select(GetPackageMetadata)
.Select(p => metadataCache.GetObject(p))
.ToList();
},
token));
}
/// <summary>
/// Process RegistrationPage
/// </summary>
/// <param name="registrationPage">Nuget registration page.</param>
/// <param name="results">Used to return nuget result.</param>
/// <param name="range">Nuget version range.</param>
/// <param name="includePrerelease">Whether to include PreRelease versions into result.</param>
/// <param name="includeUnlisted">Whether to include Unlisted versions into result.</param>
private void ProcessRegistrationPage(
RegistrationPage registrationPage,
List <PackageSearchMetadataRegistration> results,
VersionRange range, bool includePrerelease,
bool includeUnlisted,
MetadataReferenceCache metadataCache)
{
foreach (RegistrationLeafItem registrationLeaf in registrationPage.Items)
{
PackageSearchMetadataRegistration catalogEntry = registrationLeaf.CatalogEntry;
NuGetVersion version = catalogEntry.Version;
bool listed = catalogEntry.IsListed;
if (range.Satisfies(catalogEntry.Version) &&
(includePrerelease || !version.IsPrerelease) &&
(includeUnlisted || listed))
{
catalogEntry.ReportAbuseUrl = _reportAbuseResource?.GetReportAbuseUrl(catalogEntry.PackageId, catalogEntry.Version);
catalogEntry.PackageDetailsUrl = _packageDetailsUriResource?.GetUri(catalogEntry.PackageId, catalogEntry.Version);
catalogEntry = metadataCache.GetObject(catalogEntry);
results.Add(catalogEntry);
}
}
}