public async Task <AutocompleteResponse> AutocompleteAsync(AutocompleteRequest request, CancellationToken cancellationToken)
{
// TODO: Support versions autocomplete.
// See: https://github.com/loic-sharma/BaGet/issues/291
IQueryable <Package> search = _context.Packages;
if (!string.IsNullOrEmpty(request.Query))
{
var query = request.Query.ToLower();
search = search.Where(p => p.Id.ToLower().Contains(query));
}
var results = await search.Where(p => p.Listed)
.OrderByDescending(p => p.Downloads)
.Skip(request.Skip)
.Take(request.Take)
.Select(p => p.Id)
.Distinct()
.ToListAsync(cancellationToken);
return(new AutocompleteResponse(
results.Count,
results,
AutocompleteContext.Default));
}
public async Task SupportsNullParameters()
{
AutocompleteRequest lastRequest = null;
_searchService
.Setup(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()))
.ReturnsAsync(() => _autocompleteResponse)
.Callback <AutocompleteRequest>(x => lastRequest = x);
await _target.AutocompleteAsync(
skip : null,
take : null,
prerelease : null,
semVerLevel : null,
q : null,
id : null,
packageType : null,
debug : null);
_searchService.Verify(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()), Times.Once);
Assert.NotNull(lastRequest);
Assert.Equal(0, lastRequest.Skip);
Assert.Equal(20, lastRequest.Take);
Assert.False(lastRequest.IncludePrerelease);
Assert.False(lastRequest.IncludeSemVer2);
Assert.Null(lastRequest.Query);
Assert.False(lastRequest.ShowDebug);
Assert.Null(lastRequest.PackageType);
Assert.Equal(AutocompleteRequestType.PackageIds, lastRequest.Type);
}
public void CanConvertToPostRequestPayload()
{
var parameters =
new AutocompleteParameters()
{
AutocompleteMode = AutocompleteMode.OneTermWithContext,
Filter = "field eq 'text'",
HighlightPostTag = "</em>",
HighlightPreTag = "<em>",
MinimumCoverage = 33.3,
SearchFields = new[] { "a", "b", "c" },
Top = 5,
UseFuzzyMatching = true
};
AutocompleteRequest request = parameters.ToRequest("find me", "sg");
Assert.Equal(parameters.AutocompleteMode, request.AutocompleteMode);
Assert.Equal(parameters.Filter, request.Filter);
Assert.Equal(parameters.HighlightPostTag, request.HighlightPostTag);
Assert.Equal(parameters.HighlightPreTag, request.HighlightPreTag);
Assert.Equal(parameters.MinimumCoverage, request.MinimumCoverage);
Assert.Equal("find me", request.SearchText);
Assert.Equal("sg", request.SuggesterName);
Assert.Equal(parameters.SearchFields.ToCommaSeparatedString(), request.SearchFields);
Assert.Equal(parameters.Top, request.Top);
Assert.Equal(parameters.UseFuzzyMatching, request.UseFuzzyMatching);
}
public async Task PrefersPackageIdsRequestType()
{
AutocompleteRequest lastRequest = null;
_searchService
.Setup(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()))
.ReturnsAsync(() => _autocompleteResponse)
.Callback <AutocompleteRequest>(x => lastRequest = x);
await _target.AutocompleteAsync(
skip : -20,
take : 30000,
prerelease : true,
semVerLevel : "2.0.0",
q : "hello world",
id : "windows azure storage",
debug : true);
_searchService.Verify(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()), Times.Once);
Assert.NotNull(lastRequest);
Assert.Equal(-20, lastRequest.Skip);
Assert.Equal(30000, lastRequest.Take);
Assert.True(lastRequest.IncludePrerelease);
Assert.True(lastRequest.IncludeSemVer2);
Assert.Equal("hello world", lastRequest.Query);
Assert.True(lastRequest.ShowDebug);
Assert.Equal(AutocompleteRequestType.PackageIds, lastRequest.Type);
}
public async Task <AutocompleteResponse> AutocompleteAsync(
int?skip = DefaultSkip,
int?take = DefaultTake,
bool?prerelease = false,
string semVerLevel = null,
string q = null,
string id = null,
string packageType = null,
bool?testData = false,
bool?debug = false)
{
await EnsureInitializedAsync();
// If only "id" is provided, find package versions. Otherwise, find package Ids.
var type = (q != null || id == null)
? AutocompleteRequestType.PackageIds
: AutocompleteRequestType.PackageVersions;
var request = new AutocompleteRequest
{
Skip = skip ?? DefaultSkip,
Take = take ?? DefaultTake,
IncludePrerelease = prerelease ?? false,
IncludeSemVer2 = ParameterUtilities.ParseIncludeSemVer2(semVerLevel),
Query = q ?? id,
Type = type,
PackageType = packageType,
IncludeTestData = testData ?? false,
ShowDebug = debug ?? false,
};
return(await _searchService.AutocompleteAsync(request));
}
public async Task <AutocompleteResponse> Palaces(AutocompleteRequest request, ApiKey apiKey = null, HttpClient httpClient = null)
{
using (var api = new GetAddesssApi(apiKey ?? ApiKey, HttpClient ?? httpClient))
{
return(await api.Autocomplete.Places(request));
}
}
public async Task <AutocompleteResponse> AutocompleteAsync(
AutocompleteRequest request,
CancellationToken cancellationToken)
{
// TODO: Do a prefix search on the package id field.
// TODO: Support prerelease, semver2, and package type filters.
// See: https://github.com/loic-sharma/BaGet/issues/291
var parameters = new SearchParameters
{
IncludeTotalResultCount = true,
Skip = request.Skip,
Top = request.Take,
};
var response = await _searchClient.Documents.SearchAsync <PackageDocument>(
request.Query,
parameters,
cancellationToken : cancellationToken);
var results = response.Results
.Select(r => r.Document.Id)
.ToList()
.AsReadOnly();
return(new AutocompleteResponse
{
TotalHits = response.Count.Value,
Data = results,
Context = AutocompleteContext.Default
});
}
public async Task <ActionResult <AutocompleteResponse> > AutocompleteAsync(
[FromQuery(Name = "q")] string query = null,
[FromQuery] int skip = 0,
[FromQuery] int take = 20,
[FromQuery] bool prerelease = false,
[FromQuery] string semVerLevel = null,
// These are unofficial parameters
[FromQuery] string packageType = null,
CancellationToken cancellationToken = default)
{
// TODO: Support versions autocomplete.
// See: https://github.com/loic-sharma/BaGet/issues/291
var request = new AutocompleteRequest
{
Skip = skip,
Take = take,
IncludePrerelease = prerelease,
IncludeSemVer2 = semVerLevel == "2.0.0",
PackageType = packageType,
Query = query,
};
return(await _searchService.AutocompleteAsync(request, cancellationToken));
}
private static string AddSessionToken(string fullPath, AutocompleteRequest request)
{
if (!string.IsNullOrWhiteSpace(request.SessionToken?.Value))
{
fullPath += $"&session-token={request.SessionToken.Value}";
}
return(fullPath);
}
private static string AddIpAddress(string fullPath, AutocompleteRequest request)
{
if (!string.IsNullOrWhiteSpace(request.IpAddress?.Value))
{
fullPath += $"&ip-address={request.IpAddress.Value}";
}
return(fullPath);
}
/// <inheritdoc />
public async Task <AutocompleteResponse> AutocompleteAsync(AutocompleteRequest request, CancellationToken cancellationToken = default)
{
var param = (request.Type == AutocompleteRequestType.PackageIds) ? "q" : "id";
var url = AddSearchQueryString(_autocompleteUrl, request, param);
var response = await _httpClient.DeserializeUrlAsync <AutocompleteResponse>(url, cancellationToken);
return(response.GetResultOrThrow());
}
public void ExceptionIsThrownIfApikeyIsNotProvided()
{
var request = new AutocompleteRequest()
{
Sensor = false,
Input = "London"
};
var response = new PlacesService().GetAutocompleteResponse(request);
}
public async void ExecuteNotFoundReturnsEmpty()
{
var request = new AutocompleteRequest
{
Key = "a",
Term = ""
};
var json = LaraUI.JSON.Stringify(request);
var result = await AutocompleteService.Execute(json);
Assert.Equal(string.Empty, result);
}
public virtual Response <AutocompleteResult> AutocompletePost(AutocompleteRequest autocompleteRequest, RequestOptions requestOptions = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("DocumentsClient.AutocompletePost");
scope.Start();
try
{
return(RestClient.AutocompletePost(autocompleteRequest, requestOptions, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public JsonResult GetAutocomplete([FromQuery] AutocompleteRequest request)
{
if (request == null || string.IsNullOrEmpty(request.q))
{
return(new JsonResult(string.Empty));
}
using (var service = this.CurrentContext.Factory.GetService <IAuthorService>(CurrentContext.RootContext))
{
Dictionary <int, string> entries = service.GetAutocomplete(request.q);
var data = entries.Select(e => new { id = e.Key, text = e.Value }).ToArray();
return(new JsonResult(data));
}
}
public void ResponseIsNotNull()
{
var request = new AutocompleteRequest()
{
Sensor = false,
Input = "London"
};
var service = new PlacesService();
AutocompleteResponse response = null;
response = service.GetAutocompleteResponse(request);
Assert.IsNotNull(response);
}
public async Task <AutocompleteResponse> AutocompleteAsync(
AutocompleteRequest request,
CancellationToken cancellationToken)
{
var results = await SearchAsync(
request.Query,
request.Skip,
request.Take,
request.IncludePrerelease,
request.IncludeSemVer2,
cancellationToken);
var packageIds = results.Select(p => p.PackageId).ToList();
return(_responseBuilder.BuildAutocomplete(packageIds));
}
public override Task <AutocompleteReply> Autocomplete(AutocompleteRequest request, ServerCallContext context)
{
var result = new AutocompleteReply();
if (!string.IsNullOrEmpty(request.SearchQuery))
{
var matches = _products
.Where(p => p.Name.StartsWith(request.SearchQuery, StringComparison.CurrentCultureIgnoreCase))
.Select(p => new AutocompleteItem {
EAN = p.EAN, Name = p.Name
})
.Take(10); // Limit to this many results
result.Items.AddRange(matches);
}
return(Task.FromResult(result));
}
public async Task <AutocompleteResponse> AutocompleteAsync(
AutocompleteRequest request,
CancellationToken cancellationToken)
{
var results = await SearchInternalAsync(
request.Query,
request.Skip,
request.Take,
request.IncludePrerelease,
request.IncludeSemVer2,
cancellationToken);
return(new AutocompleteResponse
{
TotalHits = results.Count,
Data = results.Select(ToAutocompleteResult).ToList(),
});
}
public void ResponseWith_Types_And_Places()
{
var request = new AutocompleteRequest()
{
Sensor = false,
Input = "SK4 5DA",
Regions = true,
Components = "UK"
};
var service = new PlacesService();
AutocompleteResponse response = null;
response = service.GetAutocompleteResponse(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Predictions.Length > 0);
Assert.IsTrue(response.Status == ServiceResponseStatus.Ok);
}
public void MissingParametersAreMissingInTheRequest()
{
var parameters = new AutocompleteParameters();
// Search text and suggester name can never be null.
AutocompleteRequest request = parameters.ToRequest("welco", "sg");
Assert.True(request.AutocompleteMode.HasValue);
Assert.Equal(AutocompleteMode.OneTerm, request.AutocompleteMode.Value); // AutocompleteMode is non-nullable in the client contract.
Assert.Null(request.Filter);
Assert.Null(request.HighlightPostTag);
Assert.Null(request.HighlightPreTag);
Assert.Null(request.MinimumCoverage);
Assert.Equal("welco", request.SearchText);
Assert.Equal("sg", request.SuggesterName);
Assert.Null(request.SearchFields);
Assert.Null(request.Top);
Assert.False(request.UseFuzzyMatching.HasValue);
}
public async Task <ActionResult <AutocompleteResponse> > AutocompleteAsync(
[FromQuery(Name = "q")] string autocompleteQuery = null,
[FromQuery(Name = "id")] string versionsQuery = null,
[FromQuery] bool prerelease = false,
[FromQuery] string semVerLevel = null,
[FromQuery] int skip = 0,
[FromQuery] int take = 20,
// These are unofficial parameters
[FromQuery] string packageType = null,
CancellationToken cancellationToken = default)
{
// If only "id" is provided, find package versions. Otherwise, find package IDs.
if (versionsQuery != null && autocompleteQuery == null)
{
var request = new VersionsRequest
{
IncludePrerelease = prerelease,
IncludeSemVer2 = semVerLevel == "2.0.0",
PackageId = versionsQuery,
};
return(await _searchService.ListPackageVersionsAsync(request, cancellationToken));
}
else
{
var request = new AutocompleteRequest
{
IncludePrerelease = prerelease,
IncludeSemVer2 = semVerLevel == "2.0.0",
PackageType = packageType,
Skip = skip,
Take = take,
Query = autocompleteQuery,
};
return(await _searchService.AutocompleteAsync(request, cancellationToken));
}
}
public async Task <ObservableCollection <IAutoCompleteResultModel> > GetAutoCompleteResponse(string input)
{
var currentLocation = _locationManager.LastKnownLocation;
try
{
var request = new AutocompleteRequest
{
Input = input,
Location = new LatLng(currentLocation.Latitude, currentLocation.Longitude),
Radius = 50000,
Language = "en|ru"
};
var result = await _placesService.GetAutocompleteResponseAsync(request);
if (result?.Status != ServiceResponseStatus.Ok)
{
return(null);
}
var addresses = new ObservableCollection <IAutoCompleteResultModel>(result.Predictions.Select(p =>
new AutoCompleteResultModel
{
PrimaryText = p.StructuredFormatting?.MainText,
SecondaryText = p.StructuredFormatting?.SecondaryText,
PlaceId = p.PlaceId,
Icon = "marker.png"
}));
return(addresses);
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(null);
}
public async Task HasDefaultParameters()
{
AutocompleteRequest lastRequest = null;
_searchService
.Setup(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()))
.ReturnsAsync(() => _autocompleteResponse)
.Callback <AutocompleteRequest>(x => lastRequest = x);
await _target.AutocompleteAsync();
_searchService.Verify(x => x.AutocompleteAsync(It.IsAny <AutocompleteRequest>()), Times.Once);
Assert.NotNull(lastRequest);
Assert.Equal(0, lastRequest.Skip);
Assert.Equal(20, lastRequest.Take);
Assert.False(lastRequest.IncludePrerelease);
Assert.False(lastRequest.IncludeSemVer2);
Assert.False(lastRequest.IncludeTestData);
Assert.Null(lastRequest.Query);
Assert.False(lastRequest.ShowDebug);
Assert.Null(lastRequest.PackageType);
Assert.Equal(AutocompleteRequestType.PackageIds, lastRequest.Type);
}
public async void AutocompleteServiceRun()
{
LaraUI.InternalContext.Value = Context;
var x = new AutocompleteElement();
var provider = new MyProvider();
var options = new AutocompleteOptions
{
Provider = provider,
AutoFocus = true,
MinLength = 2,
Strict = true,
};
var doc = new Document(new MyPage(), 100);
var bridge = new Mock <IJsBridge>();
Context.JSBridge = bridge.Object;
doc.Body.AppendChild(x);
x.Start(options);
var service = new AutocompleteService();
var request = new AutocompleteRequest
{
Key = x.AutocompleteId,
Term = "B"
};
Context.RequestBody = LaraUI.JSON.Stringify(request);
var text = await service.Execute();
var response = LaraUI.JSON.Parse <AutocompleteResponse>(text);
Assert.Equal(3, response.Suggestions !.Count);
var item = response.Suggestions[0];
Assert.Equal("Red", item.Label);
Assert.Equal("R", item.Code);
}
private async void searchBox_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
{
if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput)
{
if (searchBox.Text.Trim().Length >= 2)
{
AutocompleteRequest autocompleteRequest = new AutocompleteRequest();
autocompleteRequest.Input = searchBox.Text.Trim();
autocompleteRequest.Location = new Google.Maps.LatLng(map.Center.Position.Latitude, map.Center.Position.Longitude);
AutocompleteResponse autocompleteResponse = await placesService.GetAutocompleteResponseAsync(autocompleteRequest);
if (autocompleteResponse.Status == Google.Maps.ServiceResponseStatus.Ok)
{
searchBox.Items.Clear();
addressToId.Clear();
foreach (var prediction in autocompleteResponse.Predictions)
{
searchBox.Items.Add(prediction.description);
addressToId.Add(prediction.description, prediction.PlaceId);
}
}
}
}
}
private async static Task <AutocompleteResponse> GetResponse(GetAddesssApi api, string path, ApiKey apiKey, AutocompleteRequest request)
{
if (api == null)
{
throw new ArgumentNullException(nameof(api));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (apiKey == null)
{
throw new ArgumentNullException(nameof(apiKey));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var fullPath = $"{path}places/{request.Input}?google-api-key={request.GoogleApiKey.Value}";
fullPath = AddSessionToken(fullPath, request);
fullPath = AddIpAddress(fullPath, request);
api.SetAuthorizationKey(apiKey);
var response = await api.Get(fullPath);
var json = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
var predictions = GetPredictions(json);
return(new AutocompleteResponse.Success((int)response.StatusCode, response.ReasonPhrase, json, predictions));
}
return(new AutocompleteResponse.Failed((int)response.StatusCode, response.ReasonPhrase, json));
}
public async static Task <AutocompleteResponse> Places(GetAddesssApi api, string path, ApiKey apiKey, AutocompleteRequest request)
{
return(await GetResponse(api, path, apiKey, request));
}
public async Task <AutocompleteResponse> Places(AutocompleteRequest request)
{
return(await Places(Api, Path, this.ApiKey, request));
}
public virtual Response <AutocompleteResult> AutocompletePost(Guid?clientRequestId, AutocompleteRequest autocompleteRequest, CancellationToken cancellationToken = default)
{
return(RestClient.AutocompletePost(clientRequestId, autocompleteRequest, cancellationToken));
}
