public static void AppendToQuery(this DocflowFilter filter, RequestUrlBuilder urlBuilder)
{
foreach (var(name, value) in filter.ToQueryParameters())
{
urlBuilder.AppendToQuery(name, value);
}
}
public void BuildComplexUrl_Create()
{
string expected = String.Format("http://testprefix/foo/1/bar/List(foo,2,3)/baz/(deeper:List(found,it,{0}))/biz", complexStringEscapedPath);
GreetingBuilder greetingBuilder = new GreetingBuilder()
{
id = 555,
tone = new Tone(Tone.Symbol.INSULTING),
message = "build URl for this CREATE"
};
Greeting greeting = greetingBuilder.Build();
CreateRequestBuilder <int, Greeting> requestBuilder = new CreateRequestBuilder <int, Greeting>("foo/{one}/bar/{list}/baz/{complex}/biz");
requestBuilder.SetPathKey("one", 1);
requestBuilder.SetPathKey("list", new List <object>()
{
"foo", 2, 3
});
requestBuilder.SetPathKey("complex", new Dictionary <string, object>()
{
{ "deeper", new List <object>()
{
"found", "it", complexString
} }
});
CreateRequest <int, Greeting> request = requestBuilder.Build();
RequestUrlBuilder <CreateResponse <int, Greeting> > urlBuilder = new RequestUrlBuilder <CreateResponse <int, Greeting> >(request, "http://testprefix");
Uri url = urlBuilder.Build();
Assert.AreEqual(expected, url.AbsoluteUri);
}
public BattleriteClient Build(string token)
{
if (rateLimitPolicy == default(IRateLimitPolicy))
{
rateLimitPolicy = new RateLimitPolicy();
}
var jsonSerializerSettings = new JsonApiSerializerSettings();
var requestUrlBuilder = new RequestUrlBuilder(EndPoints.BaseUrl, new List <IParameter>());
var httpClient = new HttpClient();
SetupHttpClient(token, httpClient);
var requester = new Requester.Requester(httpClient, rateLimitPolicy);
return(CreateBattleriteClient(
CreateOrGetAssetClient(),
CreateOrGetPlayerClient(
jsonSerializerSettings,
requestUrlBuilder,
requester,
CreateOrGetAssetClient()),
CreateOrGetMatchClient(requestUrlBuilder, requester)));
}
public void BuildComplexUrl_Get()
{
string expected = String.Format("http://testprefix/foo/1/bar/List(foo,2,3)/baz/(deeper:List(found,it,{0}))/biz/123", complexStringEscapedPath);
GetRequestBuilder <int, Greeting> requestBuilder = new GetRequestBuilder <int, Greeting>("foo/{one}/bar/{list}/baz/{complex}/biz");
requestBuilder.SetID(123);
requestBuilder.SetPathKey("one", 1);
requestBuilder.SetPathKey("list", new List <object>()
{
"foo", 2, 3
});
requestBuilder.SetPathKey("complex", new Dictionary <string, object>()
{
{ "deeper", new List <object>()
{
"found", "it", complexString
} }
});
GetRequest <int, Greeting> request = requestBuilder.Build();
RequestUrlBuilder <EntityResponse <Greeting> > urlBuilder = new RequestUrlBuilder <EntityResponse <Greeting> >(request, "http://testprefix");
Uri url = urlBuilder.Build();
Assert.AreEqual(expected, url.AbsoluteUri);
}
public void BuildComplexUrl_Finder()
{
string expected = String.Format("http://testprefix/foo/1/bar/List(foo,2,3)/baz/(deeper:List(found,it,{0}))/biz?q={1}", complexStringEscapedPath, complexStringEscapedQuery);
FinderRequestBuilder <Greeting, EmptyRecord> requestBuilder = new FinderRequestBuilder <Greeting, EmptyRecord>("foo/{one}/bar/{list}/baz/{complex}/biz");
requestBuilder.Name(complexString);
requestBuilder.SetPathKey("one", 1);
requestBuilder.SetPathKey("list", new List <object>()
{
"foo", 2, 3
});
requestBuilder.SetPathKey("complex", new Dictionary <string, object>()
{
{ "deeper", new List <object>()
{
"found", "it", complexString
} }
});
FinderRequest <Greeting, EmptyRecord> request = requestBuilder.Build();
RequestUrlBuilder <CollectionResponse <Greeting, EmptyRecord> > urlBuilder = new RequestUrlBuilder <CollectionResponse <Greeting, EmptyRecord> >(request, "http://testprefix");
Uri url = urlBuilder.Build();
Assert.AreEqual(expected, url.AbsoluteUri);
}
public void Should_add_empty_query_values_if_requested_to()
{
var builder = new RequestUrlBuilder("http://foo");
builder.AppendToQuery("key", string.Empty, true);
builder.Build().Query.Should().Be("?key=");
}
public void Should_not_add_empty_query_values_by_default()
{
var builder = new RequestUrlBuilder("http://foo");
builder.AppendToQuery("key", string.Empty);
builder.Build().Query.Should().BeEmpty();
}
public void Should_produce_correct_uri_when_appending_path_segments_without_slashes()
{
var builder = new RequestUrlBuilder
{
"1", "2", "3", "4"
};
builder.Build().OriginalString.Should().Be("1/2/3/4");
}
public void Should_produce_correct_uri_when_appending_path_segments_with_excess_slashes()
{
var builder = new RequestUrlBuilder
{
"11/", "/22/", "/33/", "/44"
};
builder.Build().OriginalString.Should().Be("11/22/33/44");
}
public void Should_produce_correct_uri_when_starting_from_non_empty_url_with_path()
{
var builder = new RequestUrlBuilder("initial/segments/")
{
"foo/", "bar/", "baz"
};
builder.Build().OriginalString.Should().Be("initial/segments/foo/bar/baz");
}
public void Should_produce_correct_uri_without_query_parameters()
{
var builder = new RequestUrlBuilder
{
"foo/", "bar/", "baz"
};
builder.Build().OriginalString.Should().Be("foo/bar/baz");
}
public void Should_encode_query_parameter_names_and_values()
{
var builder = new RequestUrlBuilder
{
"foo/", "bar/", "baz",
{ "a?a", "b?b" },
};
builder.Build().OriginalString.Should().Be("foo/bar/baz?a%3Fa=b%3Fb");
}
public void Should_produce_correct_uri_when_starting_from_non_empty_url_with_path_and_query()
{
var builder = new RequestUrlBuilder("foo/bar/baz?a=1")
{
{ "b", 2 },
{ "c", 3 }
};
builder.Build().OriginalString.Should().Be("foo/bar/baz?a=1&b=2&c=3");
}
public void Should_produce_correct_uri_with_query_parameters()
{
var builder = new RequestUrlBuilder
{
"foo/", "bar/", "baz",
{ "a", 1 },
{ "b", 2 }
};
builder.Build().OriginalString.Should().Be("foo/bar/baz?a=1&b=2");
}
public void Should_produce_repeatable_results()
{
for (var i = 0; i < 10; i++)
{
var url = new RequestUrlBuilder()
.AppendToPath("foo/")
.AppendToPath("bar")
.Build();
url.OriginalString.Should().Be("foo/bar");
}
}
public void Should_not_allow_to_append_to_path_after_appending_to_query()
{
var builder = new RequestUrlBuilder();
builder.AppendToPath("foo/");
builder.AppendToQuery("key", "value");
Action action = () => builder.AppendToPath("bar");
action.Should().Throw <InvalidOperationException>().Which.ShouldBePrinted();
}
public void Should_safely_handle_multiple_calls_to_build_method()
{
var builder = new RequestUrlBuilder
{
"foo", "bar", "baz"
};
var url1 = builder.Build();
var url2 = builder.Build();
url2.Should().BeSameAs(url1);
}
public async Task <RawReadStreamResult> ReadAsync(ReadStreamQuery query, string apiKey, TimeSpan timeout, CancellationToken cancellationToken = default)
{
try
{
var url = new RequestUrlBuilder("stream/read")
{
{ Constants.QueryParameters.Stream, query.Name },
{ Constants.QueryParameters.Limit, query.Limit },
{ Constants.QueryParameters.ClientShard, query.ClientShard },
{ Constants.QueryParameters.ClientShardCount, query.ClientShardCount }
}
.Build();
var body = CreateRequestBody(query.Coordinates ?? StreamCoordinates.Empty);
var request = Request
.Post(url)
.WithContentTypeHeader(Constants.ContentTypes.OctetStream)
.WithContent(body);
if (compressionEnabled)
{
request = request.WithAcceptEncodingHeader(Constants.Compression.Lz4Encoding);
}
if (!string.IsNullOrEmpty(apiKey))
{
request = request.WithHeader(Constants.HeaderNames.ApiKey, apiKey);
}
var result = await client
.SendAsync(request, timeout, cancellationToken : cancellationToken)
.ConfigureAwait(false);
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
if (operationStatus != HerculesStatus.Success)
{
if (result.Response.HasContent)
{
bufferPool.Return(result.Response.Content.Buffer);
}
return(new RawReadStreamResult(operationStatus, null, errorMessage));
}
return(new RawReadStreamResult(operationStatus, ParseReadResponseBody(result.Response)));
}
catch (Exception error)
{
log.Warn(error);
return(new RawReadStreamResult(HerculesStatus.UnknownError, null, error.Message));
}
}
private static Uri GetFullUri(string uriPath, Dictionary <string, object> uriQueryParams)
{
var urlBuilder = new RequestUrlBuilder(uriPath);
if (uriQueryParams != null)
{
foreach (var queryParam in uriQueryParams)
{
urlBuilder.AppendToQuery(queryParam.Key, queryParam.Value);
}
}
return(urlBuilder.Build());
}
public async Task <AccountData> GetAccountData(string userId)
{
var uri = new RequestUrlBuilder(_authServiceUri)
.AppendToPath("getUserData")
.AppendToQuery("userId", userId)
.Build();
var response = await _httpClient.GetAsync(uri).ConfigureAwait(false);
var data = await response.DeserializeAsync <AccountData>().ConfigureAwait(false);
return(data);
}
/// <inheritdoc />
public async Task <ReadTimelineResult <T> > ReadAsync(ReadTimelineQuery query, TimeSpan timeout, CancellationToken cancellationToken = default)
{
try
{
var url = new RequestUrlBuilder("timeline/read")
{
{ Constants.QueryParameters.Timeline, query.Name },
{ Constants.QueryParameters.Limit, query.Limit },
{ Constants.QueryParameters.ClientShard, query.ClientShard },
{ Constants.QueryParameters.ClientShardCount, query.ClientShardCount },
{ "from", EpochHelper.ToUnixTimeUtcTicks(query.From.UtcDateTime) },
{ "to", EpochHelper.ToUnixTimeUtcTicks(query.To.UtcDateTime) }
}
.Build();
var body = CreateRequestBody(query.Coordinates ?? TimelineCoordinates.Empty);
var request = Request
.Post(url)
.WithContentTypeHeader(Constants.ContentTypes.OctetStream)
.WithContent(body);
var result = await client
.SendAsync(request, timeout, cancellationToken : cancellationToken)
.ConfigureAwait(false);
try
{
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
if (operationStatus != HerculesStatus.Success)
{
return(new ReadTimelineResult <T>(operationStatus, null, errorMessage));
}
return(new ReadTimelineResult <T>(operationStatus, ParseResponseBody(result.Response)));
}
finally
{
if (result.Response.HasContent)
{
bufferPool.Return(result.Response.Content.Buffer);
}
}
}
catch (Exception error)
{
log.Error(error);
return(new ReadTimelineResult <T>(HerculesStatus.UnknownError, null, error.Message));
}
}
public void Should_not_be_usable_after_producing_an_url()
{
var builder = new RequestUrlBuilder
{
"foo/", "bar/", "baz"
};
builder.Build();
Action pathAppend = () => builder.AppendToPath("123");
Action queryAppend = () => builder.AppendToQuery("123", "456");
pathAppend.Should().Throw <ObjectDisposedException>().Which.ShouldBePrinted();
queryAppend.Should().Throw <ObjectDisposedException>().Which.ShouldBePrinted();
}
public async Task <SeekToEndStreamResult> SeekToEndAsync(SeekToEndStreamQuery query, string apiKey, TimeSpan timeout, CancellationToken cancellationToken = new CancellationToken())
{
try
{
var url = new RequestUrlBuilder("stream/seekToEnd")
{
{ Constants.QueryParameters.Stream, query.Name },
{ Constants.QueryParameters.ClientShard, query.ClientShard },
{ Constants.QueryParameters.ClientShardCount, query.ClientShardCount }
}
.Build();
var request = Request
.Get(url);
if (!string.IsNullOrEmpty(apiKey))
{
request = request.WithHeader(Constants.HeaderNames.ApiKey, apiKey);
}
var result = await client
.SendAsync(request, timeout, cancellationToken : cancellationToken)
.ConfigureAwait(false);
try
{
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
if (operationStatus != HerculesStatus.Success)
{
return(new SeekToEndStreamResult(operationStatus, null, errorMessage));
}
return(new SeekToEndStreamResult(operationStatus, ParseSeekToEndResponseBody(result.Response), errorMessage));
}
finally
{
if (result.Response.HasContent)
{
bufferPool.Return(result.Response.Content.Buffer);
}
}
}
catch (Exception error)
{
log.Warn(error);
return(new SeekToEndStreamResult(HerculesStatus.UnknownError, null, error.Message));
}
}
public async Task <PrintTaskInfo> GetTaskInfoAsync(string taskId)
{
var uri = new RequestUrlBuilder()
.AppendToPath(printerApiVersion)
.AppendToPath("Task")
.AppendToPath("Status")
.AppendToQuery("taskId", taskId)
.Build();
var result = await clusterClient.SendAsync(Request.Get(uri)).ConfigureAwait(false);
var response = result.Response;
response.EnsureSuccessStatusCode();
return(JsonConvert.DeserializeObject <PrintTaskInfo>(response.Content.ToString()));
}
public async Task <byte[]> GetTaskResultAsync(string taskId)
{
var uri = new RequestUrlBuilder()
.AppendToPath(printerApiVersion)
.AppendToPath("Task")
.AppendToPath("Result")
.AppendToQuery("taskId", taskId)
.Build();
var result = await clusterClient.SendAsync(Request.Get(uri)).ConfigureAwait(false);
var response = result.Response;
response.EnsureSuccessStatusCode();
var stringResult = JsonConvert.DeserializeObject <string>(System.Text.Encoding.UTF8.GetString(response.Content.ToArray()));
return(Convert.FromBase64String(stringResult));
}
public async Task <string> CreatePrintTaskAsync(PrintTask task)
{
var uri = new RequestUrlBuilder()
.AppendToPath(printerApiVersion)
.AppendToPath("Print")
.Build();
var request = Request.Post(uri)
.WithContentTypeHeader("application/json")
.WithContent(JsonConvert.SerializeObject(task, new JsonSerializerSettings
{
Converters = new JsonConverter[] { new StringEnumConverter() }
}));
var result = await clusterClient.SendAsync(request).ConfigureAwait(false);
var response = result.Response;
response.EnsureSuccessStatusCode();
return(JsonConvert.DeserializeObject <string>(response.Content.ToString()));
}
public Uri GetUrl(string urlPrefix)
{
RequestUrlBuilder <TResponse> requestUrlBuilder = new RequestUrlBuilder <TResponse>(this, urlPrefix);
return(requestUrlBuilder.Build());
}
public static RequestUrlBuilder AppendDateToPath(this RequestUrlBuilder builder, DateTime date)
{
return(builder.AppendToPath(date.Date.ToString("yyyy-MM-dd")));
}
