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