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)); } }