public async Task GET_with_filter_generates_correct_signature() { var fake = A.Fake <FakeHttpMessageHandler>(a => a.CallsBaseMethods()); MockAuthTimeCallWithFakeItEasy(fake); A.CallTo(() => fake.Send(A <HttpRequestMessage> .That.Matches( r => r.RequestUri.ToString().Contains("/route")))) .Returns(Responses.Get.empty_message); var c = ClientFactory.GetClient(fake); var queryParams = new QueryStringParams(); queryParams.Add("filter", "value:&é'-"); queryParams.Add("anotherfilter", "=test"); _ = await c.GetAsync("/route", queryParams); var meCall = Fake.GetCalls(fake).Where(call => call.Method.Name == "Send" && call.GetArgument <HttpRequestMessage>("request").RequestUri.ToString().Contains("/route")).First(); var requestMessage = meCall.GetArgument <HttpRequestMessage>("request"); var headers = requestMessage.Headers; Assert.AreEqual("$1$098b93d342b6db4848ec448063be2b6884e94723", headers.GetValues(Client.OVH_SIGNATURE_HEADER).First()); }
public Task <List <InventoryResource> > GetInventoriesAsync(QueryStringParams queryParams) => Collection .Find(Builders <Inventory> .Filter.Empty) .Page(queryParams) .SortByDescending(i => i.OccupiedArea) .Project(i => i.ToInventoryResource()) .ToListAsync();
/// <summary> /// Issues a cascading GET call /// </summary> /// <param name="target">API method to call</param> /// <param name="rootCallKwargs">Arguments to append to the parent URL</param> /// <param name="childrenCallsKwargs">Arguments to append to the child URL</param> /// <param name="childUrlFormat">Format of the url for subsequent calls. Use * as the placeholder. Defaults to "<target>/*</param> /// <param name="needAuth">If true, send authentication headers</param> /// <returns>An enumerator over children API Calls</returns> public IEnumerable <string> Enumerate(string target, QueryStringParams rootCallKwargs = null, QueryStringParams childrenCallsKwargs = null, string childUrlFormat = null, bool needAuth = true) { if (childUrlFormat == null) { childUrlFormat = target + "/*"; } int placeholderCount = childUrlFormat.Count(c => c == '*'); if (placeholderCount == 0) { throw new ArgumentException("Missing placeholder for childUrlFormat", "childUrlFormat"); } else if (placeholderCount > 1) { throw new ArgumentException("Too many placeholders for childUrlFormat, only one is allowed", "childUrlFormat"); } target += rootCallKwargs?.ToString(); string childKwargs = childrenCallsKwargs?.ToString(); foreach (string item in Call <IEnumerable <string> >("GET", target, null, needAuth)) { string childUrl = getChildUrl(childUrlFormat, item, childKwargs); yield return(Call("GET", childUrl, null, needAuth, isBatch: false)); } }
/// <summary> /// Issues a cascading GET call with an expected return type /// </summary> /// <typeparam name="T">Expected return type</typeparam> /// <param name="target">API method to call</param> /// <param name="rootCallKwargs">Arguments to append to the parent URL</param> /// <param name="childrenCallsKwargs">Arguments to append to the child URL</param> /// <param name="childUrlFormat">Format of the url for subsequent calls. Use * as the placeholder. Defaults to "<target>/*</param> /// <param name="needAuth">If true, send authentication headers</param> /// <returns>An enumerator over children API Calls, deserialized to T by JSON.Net</returns> public IEnumerable <T> Enumerate <T>(string target, QueryStringParams rootCallKwargs = null, QueryStringParams childrenCallsKwargs = null, string childUrlFormat = null, bool needAuth = true) { foreach (string item in Enumerate(target, rootCallKwargs, childrenCallsKwargs, childUrlFormat, needAuth)) { yield return(JsonConvert.DeserializeObject <T>(item)); } }
public void QuerySerialization() { var options = new ListOptions { Page = 1, Size = 10, Sort = "DisplayName-" }; var query = new QueryStringParams(options); Assert.Equal("page=1&size=10&sort=DisplayName-", query.ToFormUrlEncodedString()); }
public string GetStyledLayerDescritpionUrl(string serviceName, List <string> layerNames = null) { QueryStringParams parameters = new QueryStringParams() { { "request", "GetStyles" } }; if (layerNames != null && layerNames.Count > 0) { parameters.Add("layers", string.Join(',', layerNames)); } return(string.Format(_urlFormatString, serviceName, GetQueryString(parameters))); }
public string GetLegendGraphicsUrl(string serviceName, string layerName, string format, int width, int height) { QueryStringParams parameters = new QueryStringParams() { { "request", "GetLegendGraphic" }, { "layer", layerName }, { "format", format }, { "width", width.ToString() }, { "height", height.ToString() } }; return(string.Format(_urlFormatString, serviceName, GetQueryString(parameters))); }
public async Task <IActionResult> GetAllStudents([FromQuery] QueryStringParams queryStringParams) { var(student, count) = await _adminService.GetAllStudentsAsync(queryStringParams); if (student != null) { return(Ok(new { student, count })); } return(BadRequest(new { title = "Couldnt find any student" })); }
public async Task <WeatherDto> GetWeather(CancellationToken cancellationToken) { QueryStringParams["q"] = City; QueryStringParams["units"] = Units; UriBuilder.Query = QueryStringParams.ToString(); WeatherDto weather = null; try { using (var response = await HttpClient.GetAsync(UriBuilder.Uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)) { if (!response.IsSuccessStatusCode) { if (response.StatusCode == HttpStatusCode.UnprocessableEntity) { var errorStream = await response.Content.ReadAsStreamAsync(cancellationToken); // Do something with errors here. The following code is just a guide and incomplete using (var streamReader = new StreamReader(errorStream, Encoding.UTF8, true)) { //using (var jsonTextReader = new JsonTextReader(streamReader)) { //var jsonSerializer = new JsonSerializer(); //'var validationErrors = await JsonSerializer.DeserializeAsync(errorStream); } } } } response.EnsureSuccessStatusCode(); var stream = await response.Content.ReadAsStreamAsync(cancellationToken); weather = await DeserializeAsync <WeatherDto>(stream); } } catch (Exception exception) { _logger.LogError(EventIDs.EventIdHttpClient, exception, MessageTemplates.HttpClientGet, UriBuilder.Uri.AbsolutePath ); } return(weather); }
public void QuerySerializationDocumentList() { var options = new ListOptions <DocumentListFilter> { Filter = new DocumentListFilter { From = new DateTime(2018, 07, 20), To = new DateTime(2018, 07, 24) }, Page = 1, Size = 10, Sort = "DisplayName-" }; var query = new QueryStringParams(options); Assert.Equal("page=1&size=10&sort=DisplayName-&Filter.From=2018-07-20&Filter.To=2018-07-24", query.ToFormUrlEncodedString()); }
public async Task <Either <TvShow, ProblemDetails> > GetShow(string title, int season, CancellationToken cancellationToken) { QueryStringParams["t"] = title; QueryStringParams["Season"] = season.ToString(); UriBuilder.Query = QueryStringParams.ToString(); HttpStatusCode statusCode = default(HttpStatusCode); try { using (var response = await HttpClient.GetAsync(UriBuilder.Uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)) { statusCode = response.StatusCode; response.EnsureSuccessStatusCode(); var stream = await response.Content.ReadAsStreamAsync(); return(await DeserializeAsync <TvShow>(stream)); } } catch (Exception exception) { if (statusCode == HttpStatusCode.InternalServerError) { var problemDetails = new ProblemDetails(); problemDetails.Extensions.Add("HttpClientException", "An error was thrown from an API being called."); problemDetails.Title = ProblemDetailTitles.InternalServerError; problemDetails.Type = ProblemDetailTypes.InternalServerError; problemDetails.Status = (int)HttpStatusCode.InternalServerError; return(problemDetails); } if (statusCode == HttpStatusCode.Unauthorized) { var problemDetails = new ProblemDetails(); problemDetails.Extensions.Add("UnauthorisedException", "A 401 Unauthorized response was received from an API being called."); problemDetails.Title = ProblemDetailTitles.AuthorizationError; problemDetails.Type = ProblemDetailTypes.Unauthorized; problemDetails.Status = (int)HttpStatusCode.Unauthorized; return(problemDetails); } throw; } }
public async Task DELETE_as_T() { var fake = A.Fake <FakeHttpMessageHandler>(a => a.CallsBaseMethods()); MockAuthTimeCallWithFakeItEasy(fake); A.CallTo(() => fake.Send(A <HttpRequestMessage> .That.Matches( r => r.RequestUri.ToString().Contains("/ip/127.0.0.1")))) .Returns(Responses.Get.empty_message); var c = ClientFactory.GetClient(fake); var queryParams = new QueryStringParams(); queryParams.Add("filter", "value:&é'-"); queryParams.Add("anotherfilter", "=test"); var result = await c.DeleteAsync <object>("/ip/127.0.0.1"); Assert.IsNull(result); }
private object GetNextParam(object value = null) { value = value ?? Value; var result = value; if (ValueAsOtherField) { if (value is PropertyInfo) { result = Property.Name; } else { result = value; } } else { result = QueryStringParams.GetNextParam(value); } return(result); }
/// <summary> /// Issues an async GET call /// </summary> /// <param name="target">API method to call</param> /// <param name="kwargs">Arguments to append to URL</param> /// <param name="needAuth">If true, send authentication headers</param> /// <param name="timeout">If specified, overrides default <see cref="Client"/>'s timeout with a custom one</param> /// <returns>Raw API response</returns> public Task <string> GetAsync(string target, QueryStringParams kwargs = null, bool needAuth = true, TimeSpan?timeout = null) { target += kwargs?.ToString(); return(CallAsync("GET", target, null, needAuth, timeout: timeout)); }
public List <T> GetBatch <T>(string target, QueryStringParams kwargs = null, bool needAuth = true) { target += kwargs?.ToString(); return(Call <List <T> >("GET", target, null, needAuth, isBatch: true)); }
public async Task <(ICollection <StudentInfoModel>, int)> GetAllStudentsAsync(QueryStringParams queryStringParams) { IEnumerable <User> students = await _context.Users.Include(u => u.UserCourses) .ThenInclude(uc => uc.Course) .Where(u => u.RoleId == (int)RoleType.Student) .ToListAsync(); if (!string.IsNullOrEmpty(queryStringParams.SearchString)) { var searchQuery = queryStringParams.SearchString.Split(' '); int age = 0, count = 0; for (int i = 0; i < searchQuery.Length; i++) { if (int.TryParse(searchQuery[i], out age)) { count++; } } if (count > 1) { return(null, 0); } if (count == 1 && age > 0) { students = students.Where(s => s.FirstName.Contains(queryStringParams.SearchString) || s.LastName.Contains(queryStringParams.SearchString) || s.Email.Contains(queryStringParams.SearchString) || s.Age == age); } else { students = students.Where(s => s.FirstName.Contains(queryStringParams.SearchString) || s.LastName.Contains(queryStringParams.SearchString) || s.Email.Contains(queryStringParams.SearchString)); } } if (!string.IsNullOrEmpty(queryStringParams.SortOrder) && !string.IsNullOrEmpty(queryStringParams.SortField)) { queryStringParams.SortField = char.ToUpper(queryStringParams.SortField[0]) + queryStringParams.SortField.Substring(1); var field = typeof(User).GetProperty(queryStringParams.SortField); switch (queryStringParams.SortOrder) { case "ascend": { students = students.OrderBy(x => field.GetValue(x, null)); } break; case "descend": { students = students.OrderByDescending(x => field.GetValue(x, null)); } break; default: break; } } var studentsResult = PaginationHelper <User> .GetPageValues(students, queryStringParams.PageSize, queryStringParams.PageNumber); if (students != null && studentsResult != null) { return(_mapper.Map <ICollection <StudentInfoModel> >(studentsResult), students.Count()); } return(null, 0); }
/// <summary> /// Issues an async batch GET call with an expected return type /// </summary> /// <typeparam name="T">Expected return type</typeparam> /// <param name="target">API method to call</param> /// <param name="kwargs">Arguments to append to URL</param> /// <param name="needAuth">If true, send authentication headers</param> /// <param name="timeout">If specified, overrides default <see cref="Client"/>'s timeout with a custom one</param> /// <returns>API response deserialized to List<T> by JSON.Net</returns> public Task <List <T> > GetBatchAsync <T>(string target, QueryStringParams kwargs = null, bool needAuth = true, TimeSpan?timeout = null) { target += kwargs?.ToString(); return(CallAsync <List <T> >("GET", target, null, needAuth, isBatch: true, timeout: timeout)); }
public void ProcessRequest(HttpContext context) { string userName = HttpContext.Current?.User?.Identity?.Name; if (string.IsNullOrEmpty(userName)) { userName = "******"; } UserInfo userInfo = new UserInfo() { UserName = "******" }; if (!string.IsNullOrEmpty(userName)) { var qnomy = new QNomyDataService(); userInfo = qnomy.GetUserInfo(userName); } var query = new QueryStringParams(context.Request.Params); var dataService = new SchedulerDataService(); var response = WrapResponse(() => { object data = null; switch (query.Action) { case QueryStringParams.GET_STAGES: data = dataService.GetStages(userInfo.UnitId); break; case QueryStringParams.GET_CUSTOMIZEDATA: data = dataService.GetCustomizeData(userInfo.UnitId); break; case QueryStringParams.SAVE_CUSTOMIZEDATA: string objJsonCustomize = GetData(context.Request); var dataObjCustomize = JsonConvert.DeserializeObject <CustomizeData>(objJsonCustomize); data = dataService.SaveCustomizeData(dataObjCustomize); break; case QueryStringParams.GET_APPOINTMENTS: //string filterData = GetData(context.Request); //DateFromTo filter = JsonConvert.DeserializeObject<DateFromTo>(filterData); //data = dataService.GetSchedulerEvents(filter.From, filter.To, userInfo.UnitId); data = dataService.GetAppointmentsData(userInfo.UnitId); break; case QueryStringParams.SAVE_APPOINTMENT: string objJson = GetData(context.Request); var dataObj = JsonConvert.DeserializeObject <SchedulerEvent>(objJson); data = dataService.SaveAppointment(dataObj); break; case QueryStringParams.APPOINTMENT_CHANGED: string objJsonApp = GetData(context.Request); var appData = JsonConvert.DeserializeObject <AppointmentChangedData>(objJsonApp); data = dataService.AppointmentChanged(userInfo.UserId, userInfo.UnitId, appData.PreviousStageId, appData.NextStageId, appData.SchedulerEvent, appData.RouteId); break; case QueryStringParams.APPOINTMENT_CANCEL: var eventToCancel = JsonConvert.DeserializeObject <SchedulerEvent>(GetData(context.Request)); data = dataService.AppointmentCancel(userInfo.UserId, userInfo.UnitId, eventToCancel); break; default: throw new InvalidOperationException($"Action {query.Action} not supported"); } return(data); }); ResponseSetData(context.Response, response); }
public static IEnumerable <T> Page <T>(this IEnumerable <T> source, QueryStringParams queryParams) => source .Skip((queryParams.Page - 1) * queryParams.PageSize) .Take(queryParams.PageSize);
public static IFindFluent <T, U> Page <T, U>(this IFindFluent <T, U> source, QueryStringParams queryParams) => source .Skip((queryParams.Page - 1) * queryParams.PageSize) .Limit(queryParams.PageSize);
public T Get <T>(string target, QueryStringParams kwargs = null, bool needAuth = true) { target += kwargs?.ToString(); return(Call <T>("GET", target, null, needAuth)); }
/// <summary> /// Issues an async batch GET call /// </summary> /// <param name="target">API method to call</param> /// <param name="kwargs">Arguments to append to URL</param> /// <param name="needAuth">If true, send authentication headers</param> /// <returns>Raw API response</returns> public Task <string> GetBatchAsync(string target, QueryStringParams kwargs = null, bool needAuth = true) { target += kwargs?.ToString(); return(CallAsync("GET", target, null, needAuth, isBatch: true)); }