public async Task <IActionResult> Search([FromBody] SearchBody body) { if (body == null) { return(BadRequest("No search body submitted")); } var query = body.Query; DataApiSqlQuery parsedQuery; try { parsedQuery = DataApiSqlQueryParser.Parse(query); } catch (FormatException formatException) { return(BadRequest(formatException.Message)); } // Validate var dataType = parsedQuery.FromArguments; // Authorize var loggedInUsername = UsernameNormalizer.Normalize(HttpContext.User.Identity.Name); var resourceDescription = new SearchResourceDescription(dataType); var authorizationResult = await authorizationModule.AuthorizeAsync(resourceDescription, loggedInUsername); if (!authorizationResult.IsAuthorized) { return(StatusCode((int)HttpStatusCode.Unauthorized, "Not authorized")); } apiEventLogger.Log(LogLevel.Info, $"User '{authorizationResult.User.UserName}' submitted query '{query.RemoveLineBreaks()}'"); return(await SearchExecutor.PerformSearch(dataRouter, query, body.Format)); }
public async Task <IActionResult> Get([FromBody] SearchBody body) { _logger.LogInfo("Searching for shop"); var search = await searchService.SearchForShops(body.SearchQuery, body.City, body.TypeOfShop); _logger.LogInfo("Returning shops"); return(Ok(search)); }
public async Task <ActionResult> Search([FromBody] SearchBody body) { var response = await _aiSearchService.RunQueriesAsync(body.Search, body.Page); if (response == null) { return(NotFound()); } return(Ok(response)); }
private static void AddSort(SearchBody searchBody, string field, SortDirection direction) { Log.WriteLine(string.Format(" -> Add sort : {0} - {1}", field, direction)); if (searchBody.Sort == null) { searchBody.Sort = new List <Sort>(); } searchBody.Sort.Add(new Sort { Field = field, Direction = direction }); }
public static SearchBody Parse(Expression node) { Log.WriteLine("Search parser"); Log.WriteLine(string.Format(" -> Input tree : {0}", node)); var evaluated = Evaluate(node); Log.WriteLine(string.Format(" -> Evaluated tree : {0}", evaluated)); var searchBody = new SearchBody(); InternalParse(evaluated, searchBody); return(searchBody); }
private static void InternalParse(Expression node, SearchBody searchBody) { switch (node.NodeType) { case ExpressionType.Call: Call((MethodCallExpression)node, searchBody); break; case ExpressionType.Constant: break; default: throw new Exception(string.Format("not supported : {0}", node.NodeType)); } }
private static void Call(MethodCallExpression node, SearchBody searchBody) { SearchParser.InternalParse(node.Arguments[0], searchBody); Log.WriteLine(string.Format(" -> Call : {0}", node.Method.Name)); switch (node.Method.Name) { case "Where": ParseFilter(node.Arguments[1], searchBody); break; case "Query": ParseQuery(node.Arguments[1], searchBody); break; case "Take": ParseTake(node.Arguments[1], searchBody); break; case "Skip": ParseSkip(node.Arguments[1], searchBody); break; case "OrderBy": case "ThenBy": ParseSort(node.Arguments[1], searchBody, SortDirection.Ascending); break; case "OrderByDescending": case "ThenByDescending": ParseSort(node.Arguments[1], searchBody, SortDirection.Descending); break; case "OrderByScore": case "ThenByScore": AddSort(searchBody, "_score", SortDirection.Ascending); break; case "OrderByScoreDescending": case "ThenByScoreDescending": AddSort(searchBody, "_score", SortDirection.Descending); break; default: throw new Exception(string.Format("method not supported : {0}", node.Method.Name)); } }
private static void ParseFilter(Expression node, SearchBody searchBody) { Log.WriteLine(string.Format(" -> Parse filter : {0}", node)); searchBody.Filter = FilterCombiner.CombineAnd(searchBody.Filter, FilterParser.Parse(ExpressionParser.Strip(node))); }
/// <summary> /// [EARLY ACCESS] Search: Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <returns>PagedResourceListOfStorageObject</returns> public PagedResourceListOfStorageObject Search(SearchBody searchBody, string page = default(string), List <string> sortBy = default(List <string>), int?limit = default(int?), string filter = default(string)) { Lusid.Drive.Sdk.Client.ApiResponse <PagedResourceListOfStorageObject> localVarResponse = SearchWithHttpInfo(searchBody, page, sortBy, limit, filter); return(localVarResponse.Data); }
private static void ParseSkip(Expression node, SearchBody searchBody) { Log.WriteLine(string.Format(" -> Parse skip : {0}", node)); searchBody.From = ExpressionParser.ParseConstant <int>(node); }
private static void ParseSort(Expression node, SearchBody searchBody, SortDirection direction) { Log.WriteLine(string.Format(" -> Parse sort : {0}", node)); AddSort(searchBody, ExpressionParser.ParseMember(ExpressionParser.Strip(node)), direction); }
private static void ParseQuery(Expression node, SearchBody searchBody) { Log.WriteLine(string.Format(" -> Parse query : {0}", node)); searchBody.Query = QueryParser.Parse(ExpressionParser.Strip(node)); }
private static void ParseTake(Expression node, SearchBody searchBody) { Log.WriteLine(string.Format(" -> Parse take : {0}", node)); searchBody.Size = ExpressionParser.ParseConstant <int>(node); }
/// <summary> /// [EARLY ACCESS] Search: Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <param name="cancellationToken">Cancellation Token to cancel the request.</param> /// <returns>Task of PagedResourceListOfStorageObject</returns> public async System.Threading.Tasks.Task <PagedResourceListOfStorageObject> SearchAsync(SearchBody searchBody, string page = default(string), List <string> sortBy = default(List <string>), int?limit = default(int?), string filter = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { Lusid.Drive.Sdk.Client.ApiResponse <PagedResourceListOfStorageObject> localVarResponse = await SearchWithHttpInfoAsync(searchBody, page, sortBy, limit, filter, cancellationToken).ConfigureAwait(false); return(localVarResponse.Data); }
/// <summary> /// [BETA] Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <returns>Task of ApiResponse (PagedResourceListOfStorageObject)</returns> public async System.Threading.Tasks.Task <ApiResponse <PagedResourceListOfStorageObject> > SearchAsyncWithHttpInfo(SearchBody searchBody, string page = null, List <string> sortBy = null, int?limit = null, string filter = null) { // verify the required parameter 'searchBody' is set if (searchBody == null) { throw new ApiException(400, "Missing required parameter 'searchBody' when calling SearchApi->Search"); } var localVarPath = "./api/search"; var localVarPathParams = new Dictionary <String, String>(); var localVarQueryParams = new List <KeyValuePair <String, String> >(); var localVarHeaderParams = new Dictionary <String, String>(this.Configuration.DefaultHeader); var localVarFormParams = new Dictionary <String, String>(); var localVarFileParams = new Dictionary <String, FileParameter>(); Object localVarPostBody = null; // to determine the Content-Type header String[] localVarHttpContentTypes = new String[] { "application/json" }; String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes); // to determine the Accept header String[] localVarHttpHeaderAccepts = new String[] { "text/plain", "application/json", "text/json" }; String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts); if (localVarHttpHeaderAccept != null) { localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept); } if (page != null) { localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "page", page)); // query parameter } if (sortBy != null) { localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("multi", "sortBy", sortBy)); // query parameter } if (limit != null) { localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "limit", limit)); // query parameter } if (filter != null) { localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "filter", filter)); // query parameter } if (searchBody != null && searchBody.GetType() != typeof(byte[])) { localVarPostBody = this.Configuration.ApiClient.Serialize(searchBody); // http body (model) parameter } else { localVarPostBody = searchBody; // byte array } // authentication (oauth2) required // oauth required if (!String.IsNullOrEmpty(this.Configuration.AccessToken)) { localVarHeaderParams["Authorization"] = "Bearer " + this.Configuration.AccessToken; } // set the LUSID header localVarHeaderParams["X-LUSID-Sdk-Language"] = "C#"; localVarHeaderParams["X-LUSID-Sdk-Version"] = "0.1.185"; // make the HTTP request IRestResponse localVarResponse = (IRestResponse)await this.Configuration.ApiClient.CallApiAsync(localVarPath, Method.POST, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams, localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int)localVarResponse.StatusCode; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("Search", localVarResponse); if (exception != null) { throw exception; } } return(new ApiResponse <PagedResourceListOfStorageObject>(localVarStatusCode, localVarResponse.Headers.ToDictionary(x => x.Key, x => string.Join(",", x.Value)), (PagedResourceListOfStorageObject)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(PagedResourceListOfStorageObject)))); }
/// <summary> /// [BETA] Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <returns>Task of PagedResourceListOfStorageObject</returns> public async System.Threading.Tasks.Task <PagedResourceListOfStorageObject> SearchAsync(SearchBody searchBody, string page = null, List <string> sortBy = null, int?limit = null, string filter = null) { ApiResponse <PagedResourceListOfStorageObject> localVarResponse = await SearchAsyncWithHttpInfo(searchBody, page, sortBy, limit, filter); return(localVarResponse.Data); }
/// <summary> /// [BETA] Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <returns>PagedResourceListOfStorageObject</returns> public PagedResourceListOfStorageObject Search(SearchBody searchBody, string page = null, List <string> sortBy = null, int?limit = null, string filter = null) { ApiResponse <PagedResourceListOfStorageObject> localVarResponse = SearchWithHttpInfo(searchBody, page, sortBy, limit, filter); return(localVarResponse.Data); }
/// <summary> /// [EARLY ACCESS] Search: Search for a file or folder with a given name and path /// </summary> /// <exception cref="Lusid.Drive.Sdk.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="searchBody">Search parameters</param> /// <param name="page"> (optional)</param> /// <param name="sortBy"> (optional)</param> /// <param name="limit"> (optional)</param> /// <param name="filter"> (optional, default to "")</param> /// <param name="cancellationToken">Cancellation Token to cancel the request.</param> /// <returns>Task of ApiResponse (PagedResourceListOfStorageObject)</returns> public async System.Threading.Tasks.Task <Lusid.Drive.Sdk.Client.ApiResponse <PagedResourceListOfStorageObject> > SearchWithHttpInfoAsync(SearchBody searchBody, string page = default(string), List <string> sortBy = default(List <string>), int?limit = default(int?), string filter = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { // verify the required parameter 'searchBody' is set if (searchBody == null) { throw new Lusid.Drive.Sdk.Client.ApiException(400, "Missing required parameter 'searchBody' when calling SearchApi->Search"); } Lusid.Drive.Sdk.Client.RequestOptions localVarRequestOptions = new Lusid.Drive.Sdk.Client.RequestOptions(); String[] _contentTypes = new String[] { "application/json" }; // to determine the Accept header String[] _accepts = new String[] { "text/plain", "application/json", "text/json" }; var localVarContentType = Lusid.Drive.Sdk.Client.ClientUtils.SelectHeaderContentType(_contentTypes); if (localVarContentType != null) { localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType); } var localVarAccept = Lusid.Drive.Sdk.Client.ClientUtils.SelectHeaderAccept(_accepts); if (localVarAccept != null) { localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept); } if (page != null) { localVarRequestOptions.QueryParameters.Add(Lusid.Drive.Sdk.Client.ClientUtils.ParameterToMultiMap("", "page", page)); } if (sortBy != null) { localVarRequestOptions.QueryParameters.Add(Lusid.Drive.Sdk.Client.ClientUtils.ParameterToMultiMap("multi", "sortBy", sortBy)); } if (limit != null) { localVarRequestOptions.QueryParameters.Add(Lusid.Drive.Sdk.Client.ClientUtils.ParameterToMultiMap("", "limit", limit)); } if (filter != null) { localVarRequestOptions.QueryParameters.Add(Lusid.Drive.Sdk.Client.ClientUtils.ParameterToMultiMap("", "filter", filter)); } localVarRequestOptions.Data = searchBody; // authentication (oauth2) required // oauth required if (!String.IsNullOrEmpty(this.Configuration.AccessToken)) { localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken); } // set the LUSID header localVarRequestOptions.HeaderParameters.Add("X-LUSID-Sdk-Language", "C#"); localVarRequestOptions.HeaderParameters.Add("X-LUSID-Sdk-Version", "0.1.374"); // make the HTTP request var localVarResponse = await this.AsynchronousClient.PostAsync <PagedResourceListOfStorageObject>("/api/search", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false); if (this.ExceptionFactory != null) { Exception _exception = this.ExceptionFactory("Search", localVarResponse); if (_exception != null) { throw _exception; } } return(localVarResponse); }