public IEnumerable <string> Autocomplete(NuGetSearchTerm autocompleteSearchTerm, RequestWrapper request, WildcardPattern acceptedPattern, bool allowPrerelease)
{
try
{
request.Debug(Messages.DebugInfoCallMethod3, "NuGetAutoCompleteFeed3", "Autocomplete", autocompleteSearchTerm.ToString());
return(base.Execute <IEnumerable <string> >((baseUrl) =>
{
HttpQueryBuilder qb = new HttpQueryBuilder();
if (autocompleteSearchTerm.Term == NuGetSearchTerm.NuGetSearchTermType.Id)
{
qb.Add(Constants.PackageIdQueryParam, autocompleteSearchTerm.Text);
}
else if (autocompleteSearchTerm.Term == NuGetSearchTerm.NuGetSearchTermType.AutoComplete)
{
qb.Add(Constants.QueryQueryParam, autocompleteSearchTerm.Text);
}
if (allowPrerelease)
{
qb.Add(Constants.PrereleaseQueryParam, "true");
}
qb.Add(Constants.TakeQueryParam, Constants.SearchPageCount)
.Add(Constants.SemVerLevelQueryParam, Constants.SemVerLevel2);
return NuGetWebUtility.GetResults <dynamic, string>(request, (dynamic root) =>
{
long res = -1;
if (root.HasProperty("totalhits"))
{
res = root.totalhits;
request.Debug(Resources.Messages.TotalPackagesDiscovered, res);
}
else
{
request.Warning(Resources.Messages.JsonSchemaMismatch, "totalhits");
request.Debug(Resources.Messages.JsonObjectDump, DynamicJsonParser.Serialize(root));
}
return res;
}, (dynamic root) => GetAutoCompleteResults(root, autocompleteSearchTerm, acceptedPattern), (long resultsToSkip) =>
{
if (resultsToSkip > 0)
{
HttpQueryBuilder currentQb = qb.CloneAdd(Constants.SkipQueryParam, resultsToSkip.ToString());
return currentQb.AddQueryString(baseUrl);
}
return qb.AddQueryString(baseUrl);
}, (string content) =>
{
return DynamicJsonParser.Parse(content);
}, Constants.SearchPageCountInt);
}));
}
finally
{
request.Debug(Messages.DebugInfoReturnCall, "NuGetAutoCompleteFeed3", "Autocomplete");
}
}
public static NuGetResourceCollection2 Make(string baseUrl)
{
NuGetResourceCollection2 collection = new NuGetResourceCollection2();
if (baseUrl != null)
{
collection.PackagesFeed = new NuGetPackageFeed2(baseUrl);
collection.QueryFeed = new NuGetQueryFeed2(baseUrl);
collection.FilesFeed = new NuGetFilesFeed2();
}
collection.GetSearchQueryDelegate = (terms) =>
{
string searchString = String.Empty;
IEnumerable <NuGetSearchTerm> tagTerms = terms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.Tag);
NuGetSearchTerm searchTerm = terms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.SearchTerm).FirstOrDefault();
if (searchTerm != null)
{
searchString = searchTerm.Text;
}
searchString = terms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.Tag)
.Aggregate(searchString, (current, tag) => current + " tag:" + tag.Text);
return(searchString);
};
return(collection);
}
public NuGetSearchResult Search(NuGetSearchContext searchContext, RequestWrapper request)
{
// This is a search scenario, so it should be safe to skip some metadata for the sake of performance
searchContext.EnableDeepMetadataBypass = true;
return(base.Execute <NuGetSearchResult>((baseUrl) =>
{
// For now we'll just get all versions and return the latest
HttpQueryBuilder qb = new HttpQueryBuilder();
// Once searchTermQb encodes the searchTerm, don't encode the ":" part of the resulting string
qb.Add(Constants.QueryQueryParam, this.ResourcesCollection.GetSearchQueryDelegate(searchContext.SearchTerms), separator: "=", encode: false).Add(Constants.TakeQueryParam, Constants.SearchPageCount)
.Add(Constants.SemVerLevelQueryParam, Constants.SemVerLevel2);
if (searchContext.AllowPrerelease)
{
qb.Add(Constants.PrereleaseQueryParam, "true");
}
NuGetSearchTerm searchTerm = searchContext.SearchTerms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.SearchTerm).FirstOrDefault();
IEnumerable <IPackage> packages = SearchPackagesWithBackup(baseUrl, qb, request, searchContext, searchTerm);
return searchContext.MakeResult(packages, versionPostFilterRequired: true, namePostFilterRequired: false, containsPostFilterRequired: false);
}));
}
public static bool IsValidByName(PackageEntryInfo packageEntry, NuGetSearchContext searchContext)
{
NuGetSearchTerm originalPsTerm = searchContext.SearchTerms == null ?
null : searchContext.SearchTerms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.OriginalPSPattern).FirstOrDefault();
bool valid = true;
if (originalPsTerm != null)
{
if (!String.IsNullOrWhiteSpace(originalPsTerm.Text) && SMA.WildcardPattern.ContainsWildcardCharacters(originalPsTerm.Text))
{
// Applying the wildcard pattern matching
const SMA.WildcardOptions wildcardOptions = SMA.WildcardOptions.CultureInvariant | SMA.WildcardOptions.IgnoreCase;
var wildcardPattern = new SMA.WildcardPattern(originalPsTerm.Text, wildcardOptions);
valid = wildcardPattern.IsMatch(packageEntry.Id);
}
else if (!String.IsNullOrWhiteSpace(originalPsTerm.Text))
{
valid = packageEntry.Id.IndexOf(originalPsTerm.Text, StringComparison.OrdinalIgnoreCase) > -1;
}
}
return(valid);
}
private IEnumerable <IPackage> SearchPackagesWithBackup(string baseUrl, HttpQueryBuilder qb, RequestWrapper request, NuGetSearchContext searchContext, NuGetSearchTerm searchTerm)
{
// First execute the actual search
HashSet <string> foundPackageIds = new HashSet <string>();
return(NuGetWebUtility.GetResults <dynamic, PackageBase>(request, (dynamic root) =>
{
long res = -1;
if (root.HasProperty("totalhits"))
{
res = root.totalhits;
request.Debug(Resources.Messages.TotalPackagesDiscovered, res);
}
else
{
request.Warning(Resources.Messages.JsonSchemaMismatch, "totalhits");
request.Debug(Resources.Messages.JsonObjectDump, DynamicJsonParser.Serialize(root));
}
return res;
}, (dynamic root) => GetPackageCollectionsForSearchResult(root, searchContext, searchTerm, foundPackageIds, request), (long packagesToSkip) =>
{
if (packagesToSkip > 0)
{
HttpQueryBuilder currentQb = qb.CloneAdd(Constants.SkipQueryParam, packagesToSkip.ToString());
return currentQb.AddQueryString(baseUrl);
}
return qb.AddQueryString(baseUrl);
}, (string content) =>
{
return DynamicJsonParser.Parse(content);
}, Constants.SearchPageCountInt));
}
private IEnumerable <IEnumerable <PackageBase> > GetPackageCollectionsForSearchResult(dynamic searchResult, NuGetSearchContext searchContext, NuGetSearchTerm searchTerm, HashSet <string> foundPackageIds, RequestWrapper request)
{
if (searchResult.HasProperty("data"))
{
foreach (dynamic packageEntry in searchResult.data)
{
foundPackageIds.Add(packageEntry.id);
yield return(GetPackagesForPackageEntry(packageEntry, searchContext, request));
}
}
}
public IEnumerable <string> Autocomplete(NuGetSearchTerm autocompleteSearchTerm, RequestWrapper request, bool allowPrerelease)
{
return(Autocomplete(autocompleteSearchTerm, request, acceptedPattern: null, allowPrerelease: allowPrerelease));
}
public IEnumerable <string> Autocomplete(NuGetSearchTerm autocompleteSearchTerm, NuGetRequest request)
{
return(Autocomplete(autocompleteSearchTerm, new RequestWrapper(request), request.AllowPrereleaseVersions.Value));
}
private IEnumerable <IEnumerable <string> > GetAutoCompleteResults(dynamic root, NuGetSearchTerm autocompleteSearchTerm, WildcardPattern acceptedPattern)
{
foreach (string rValue in root.data)
{
// "AutoComplete" for NuGet is slightly different than the PS definition
// We only want the matches that match the input accepted pattern or start with the search term if no accepted pattern is used
if (autocompleteSearchTerm.Term == NuGetSearchTerm.NuGetSearchTermType.AutoComplete &&
((acceptedPattern == null && !rValue.StartsWith(autocompleteSearchTerm.Text, StringComparison.OrdinalIgnoreCase)) ||
acceptedPattern.IsMatch(rValue)))
{
continue;
}
yield return(YieldResultAsEnumerable(rValue));
}
}
