public FilterQueryBuilder()
{
m_requestUriBuilder = new RequestUriBuilder
{
QueryParameters = new Dictionary<string, string>(),
RestUriPath = "/filter"
};
}
public virtual DynamicRequest DetectEntireSeriesRequest()
{
Request req = HttpPipeline.CreateRequest();
req.Method = RequestMethod.Post;
RequestUriBuilder uriBuilder = new RequestUriBuilder();
uriBuilder.Reset(Endpoint);
uriBuilder.AppendPath("anomalydetector/v1.0/timeseries/entire/detect", false);
req.Uri = uriBuilder;
req.Headers.SetValue("Content-Type", "application/json");
return(new DynamicRequest(req, HttpPipeline));
}
public static async Task <List <SubscriptionInfo> > GetSubscriptionsAsync(ApiConfiguration configuration, HttpClient httpClient, string dataType = null)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/subscription/getsubscriptions");
if (!string.IsNullOrEmpty(dataType))
{
requestUri += $"?dataType={Uri.EscapeDataString(dataType)}";
}
var response = await httpClient.GetAsync(requestUri);
ErrorReporter.EnsureSuccesStatusCode(response);
var stream = await response.Content.ReadAsStreamAsync();
return(await stream.ReadAllSearchResultsAsync <SubscriptionInfo>());
}
public static async Task ReportTo(
ApiConfiguration configuration,
HttpClient httpClient,
string recipient,
string dataType,
string dataObjectId)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/subscription/reportto");
requestUri += $"?recipient={Uri.EscapeDataString(recipient)}";
requestUri += $"&dataType={Uri.EscapeDataString(dataType)}";
requestUri += $"&id={Uri.EscapeDataString(dataObjectId)}";
var response = await httpClient.GetAsync(requestUri);
ErrorReporter.EnsureSuccesStatusCode(response);
}
public static bool IsAvailable(ApiConfiguration configuration, HttpClient httpClient)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/servicestatus/ping");
try
{
var response = httpClient.GetAsync(requestUri).Result;
ErrorReporter.EnsureSuccesStatusCode(response);
var content = response.Content.ReadAsStringAsync().Result;
return(content.ToLowerInvariant() == "pong");
}
catch
{
return(false);
}
}
public void SettingAllFields()
{
var selector = new SettingSelector
{
KeyFilter = "key",
Fields = SettingFields.All
};
var builder = new RequestUriBuilder();
builder.Reset(new Uri("http://localhost/"));
ConfigurationClient.BuildBatchQuery(builder, selector, null);
Assert.AreEqual($"http://localhost/?key=key", builder.ToUri().AbsoluteUri);
}
public void SettingAllFields()
{
var selector = new SettingSelector("key")
{
Fields = SettingFields.All
};
var builder = new RequestUriBuilder
{
Uri = new Uri("http://localhost/")
};
ConfigurationClient.BuildBatchQuery(builder, selector, null);
Assert.AreEqual($"http://localhost/?key=key", builder.Uri.AbsoluteUri);
}
public Uri CreateFirstPageUri(string path, params ValueTuple <string, string>[] queryParams)
{
var firstPage = new RequestUriBuilder();
firstPage.Reset(_vaultUri);
firstPage.AppendPath(path, escape: false);
firstPage.AppendQuery("api-version", ApiVersion);
foreach ((string, string)tuple in queryParams)
{
firstPage.AppendQuery(tuple.Item1, tuple.Item2);
}
return(firstPage.ToUri());
}
public static async Task <Stream> GetViewAsync(
ApiConfiguration configuration,
HttpClient httpClient,
string viewId,
ResultFormat resultFormat,
Dictionary <string, string> parameters = null)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/view/get");
requestUri += BuildGetQuery(viewId, parameters, resultFormat);
var response = await httpClient.GetAsync(requestUri);
ErrorReporter.EnsureSuccesStatusCode(response);
return(await response.Content.ReadAsStreamAsync());
}
public void SettingQueryToEmptyRemovesQuestionMark(string query)
{
var uriBuilder = new RequestUriBuilder
{
Scheme = "http",
Host = "localhost",
Port = 80,
Query = "a"
};
Assert.AreEqual("http://localhost/?a", uriBuilder.ToUri().ToString());
uriBuilder.Query = query;
Assert.AreEqual("http://localhost/", uriBuilder.ToUri().ToString());
}
public void FilterOnlyLabel()
{
var label = "my-label";
var selector = new SettingSelector
{
LabelFilter = label
};
var builder = new RequestUriBuilder();
builder.Reset(new Uri("http://localhost/"));
ConfigurationClient.BuildBatchQuery(builder, selector, null);
Assert.AreEqual($"http://localhost/?label={label}", builder.ToUri().AbsoluteUri);
}
public void FilterReservedCharacter()
{
var selector = new SettingSelector
{
KeyFilter = @"my_key,key\,key",
LabelFilter = @"my_label,label\,label"
};
var builder = new RequestUriBuilder();
builder.Reset(new Uri("http://localhost/"));
ConfigurationClient.BuildBatchQuery(builder, selector, null);
Assert.AreEqual(@"http://localhost/?key=my_key%2Ckey%5C%2Ckey&label=my_label%2Clabel%5C%2Clabel", builder.ToUri().AbsoluteUri);
}
public void AppendingPathWithSpecialCharacters()
{
var uriBuilder = new RequestUriBuilder();
uriBuilder.Reset(new Uri("http://localhost/"));
uriBuilder.AppendPath("/");
uriBuilder.AppendPath("~!@#$%^&*()_+");
uriBuilder.AppendPath("b/");
Assert.AreEqual("http://localhost/~%21%40%23%24%25%5E%26%2A%28%29_%2Bb%2F", uriBuilder.ToString());
#if NETCOREAPP
Assert.AreEqual("http://localhost/~%21%40%23%24%25^%26%2A%28%29_%2Bb%2F", uriBuilder.ToUri().ToString());
#else
Assert.AreEqual("http://localhost/~!%40%23%24%25^%26*()_%2Bb%2F", uriBuilder.ToUri().ToString());
#endif
}
public Uri CreateFirstPageUri(string path, params ValueTuple <string, string>[] queryParams)
{
var firstPage = new RequestUriBuilder
{
Uri = _vaultUri,
};
firstPage.AppendPath(path);
firstPage.AppendQuery("api-version", ApiVersion);
foreach (var tuple in queryParams)
{
firstPage.AppendQuery(tuple.Item1, tuple.Item2);
}
return(firstPage.Uri);
}
public async Task <ViewConfiguration> GetRepositoriesAsync(
string vcb = default,
CancellationToken cancellationToken = default
)
{
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/2019-06-17/repo",
false);
if (!string.IsNullOrEmpty(vcb))
{
_url.AppendQuery("_vcb", Client.Serialize(vcb));
}
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Get;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnGetRepositoriesFailed(_req, _res).ConfigureAwait(false);
}
if (_res.ContentStream == null)
{
await OnGetRepositoriesFailed(_req, _res).ConfigureAwait(false);
}
using (var _reader = new StreamReader(_res.ContentStream))
{
var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
var _body = Client.Deserialize <ViewConfiguration>(_content);
return(_body);
}
}
}
}
public static async Task <string> SubscribeAsync(
ApiConfiguration configuration,
HttpClient httpClient,
string dataType,
IList <DataModificationType> modificationTypes,
string filter = null)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/subscription/subscribe");
var body = ConstructSubscriptionBody(dataType, modificationTypes, filter);
var response = await httpClient.PostAsync(requestUri, body);
ErrorReporter.EnsureSuccesStatusCode(response);
var subscriptionId = await response.Content.ReadAsStringAsync();
return(subscriptionId);
}
public async Task DeletePipelineFromChannelAsync(
int channelId,
int pipelineId,
CancellationToken cancellationToken = default
)
{
if (channelId == default(int))
{
throw new ArgumentNullException(nameof(channelId));
}
if (pipelineId == default(int))
{
throw new ArgumentNullException(nameof(pipelineId));
}
const string apiVersion = "2019-01-16";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/channels/{channelId}/pipelines/{pipelineId}".Replace("{channelId}", Uri.EscapeDataString(Client.Serialize(channelId))).Replace("{pipelineId}", Uri.EscapeDataString(Client.Serialize(pipelineId))),
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Delete;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnDeletePipelineFromChannelFailed(_req, _res).ConfigureAwait(false);
}
return;
}
}
}
private void BuildUriForRoute(string route, RequestUriBuilder builder, TextAnalyticsRequestOptions options)
{
builder.Reset(_baseUri);
builder.AppendPath(TextAnalyticsRoute, escape: false);
builder.AppendPath(_apiVersion, escape: false);
builder.AppendPath(route, escape: false);
if (options.IncludeStatistics)
{
builder.AppendQuery(ShowStatistics, "true");
}
if (!string.IsNullOrEmpty(options.ModelVersion))
{
builder.AppendQuery(ModelVersion, options.ModelVersion);
}
}
public static async Task <ViewInformation> CreateViewAsync(
ApiConfiguration configuration,
HttpClient httpClient,
string query,
DateTime expires,
string viewId = null)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/view/create");
var body = ConstructCreateViewBody(query, expires, viewId);
var response = await httpClient.PostAsync(requestUri, body);
ErrorReporter.EnsureSuccesStatusCode(response);
var json = await response.Content.ReadAsStringAsync();
return(ConfiguredJsonSerializer.Deserialize <ViewInformation>(json));
}
public async Task <IImmutableList <ContainerInformation> > ListAsync(
bool?getSasTokens = default,
CancellationToken cancellationToken = default
)
{
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/2019-06-17/storage",
false);
if (getSasTokens != default(bool?))
{
_url.AppendQuery("getSasTokens", Client.Serialize(getSasTokens));
}
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Get;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnListFailed(_req, _res).ConfigureAwait(false);
}
if (_res.ContentStream == null)
{
await OnListFailed(_req, _res).ConfigureAwait(false);
}
using (var _reader = new StreamReader(_res.ContentStream))
{
var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
var _body = Client.Deserialize <IImmutableList <ContainerInformation> >(_content);
return(_body);
}
}
}
}
public async Task RetrySubscriptionActionAsyncAsync(
Guid id,
long timestamp,
CancellationToken cancellationToken = default
)
{
if (id == default(Guid))
{
throw new ArgumentNullException(nameof(id));
}
if (timestamp == default(long))
{
throw new ArgumentNullException(nameof(timestamp));
}
const string apiVersion = "2019-01-16";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/subscriptions/{id}/retry/{timestamp}".Replace("{id}", Uri.EscapeDataString(Client.Serialize(id))).Replace("{timestamp}", Uri.EscapeDataString(Client.Serialize(timestamp))),
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Post;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnRetrySubscriptionActionAsyncFailed(_req, _res).ConfigureAwait(false);
}
return;
}
}
}
public async Task BulkAddLocationsAsync(
IImmutableList <Models.AssetAndLocation> body,
CancellationToken cancellationToken = default
)
{
if (body == default(IImmutableList <Models.AssetAndLocation>))
{
throw new ArgumentNullException(nameof(body));
}
const string apiVersion = "2020-02-20";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/assets/bulk-add-locations",
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Post;
if (body != default(IImmutableList <Models.AssetAndLocation>))
{
_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));
_req.Headers.Add("Content-Type", "application/json; charset=utf-8");
}
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnBulkAddLocationsFailed(_req, _res).ConfigureAwait(false);
}
return;
}
}
}
public void FilterNullLabel()
{
var selector = new SettingSelector()
{
Labels = new List <string>()
{
""
},
};
var builder = new RequestUriBuilder();
builder.Uri = new Uri("http://localhost/");
ConfigurationClient.BuildBatchQuery(builder, selector, null);
Assert.AreEqual("http://localhost/?key=*&label=%00", builder.Uri.AbsoluteUri);
}
private string NormalizeUri(string uriToNormalize)
{
var req = new RequestUriBuilder();
var uri = new Uri(uriToNormalize);
req.Reset(uri);
req.Query = "";
NameValueCollection queryParams = HttpUtility.ParseQueryString(uri.Query);
foreach (string param in queryParams)
{
req.AppendQuery(
param,
VolatileQueryParameters.Contains(param) ? VolatileValue : queryParams[param]);
}
return(req.ToUri().ToString());
}
public async Task RemoveAssetLocationFromAssetAsync(
int assetId,
int assetLocationId,
CancellationToken cancellationToken = default
)
{
if (assetId == default(int))
{
throw new ArgumentNullException(nameof(assetId));
}
if (assetLocationId == default(int))
{
throw new ArgumentNullException(nameof(assetLocationId));
}
const string apiVersion = "2020-02-20";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/assets/{assetId}/locations/{assetLocationId}".Replace("{assetId}", Uri.EscapeDataString(Client.Serialize(assetId))).Replace("{assetLocationId}", Uri.EscapeDataString(Client.Serialize(assetLocationId))),
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Delete;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnRemoveAssetLocationFromAssetFailed(_req, _res).ConfigureAwait(false);
}
return;
}
}
}
private string GetOriginalPath()
{
// applicationInitialization request might have trailing \0 character included in the length
// check and skip it
var rawUrlInBytes = GetRawUrlInBytes();
if (rawUrlInBytes.Length > 0 && rawUrlInBytes[rawUrlInBytes.Length - 1] == 0)
{
var newRawUrlInBytes = new byte[rawUrlInBytes.Length - 1];
Array.Copy(rawUrlInBytes, newRawUrlInBytes, newRawUrlInBytes.Length);
rawUrlInBytes = newRawUrlInBytes;
}
var originalPath = RequestUriBuilder.DecodeAndUnescapePath(rawUrlInBytes);
return(originalPath);
}
public async Task CancelAsync(
string job,
string jobCancellationToken = default,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrEmpty(job))
{
throw new ArgumentNullException(nameof(job));
}
const string apiVersion = "2019-06-17";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/jobs/{job}/cancel".Replace("{job}", Uri.EscapeDataString(Client.Serialize(job))),
false);
if (!string.IsNullOrEmpty(jobCancellationToken))
{
_url.AppendQuery("jobCancellationToken", Client.Serialize(jobCancellationToken));
}
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Post;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnCancelFailed(_req, _res).ConfigureAwait(false);
}
return;
}
}
}
public async Task <Models.Asset> GetAssetAsync(
int id,
CancellationToken cancellationToken = default
)
{
const string apiVersion = "2020-02-20";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/assets/{id}".Replace("{id}", Uri.EscapeDataString(Client.Serialize(id))),
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Get;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnGetAssetFailed(_req, _res).ConfigureAwait(false);
}
if (_res.ContentStream == null)
{
await OnGetAssetFailed(_req, _res).ConfigureAwait(false);
}
using (var _reader = new StreamReader(_res.ContentStream))
{
var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
var _body = Client.Deserialize <Models.Asset>(_content);
return(_body);
}
}
}
}
protected override RequestUriBuilder GetUriBase()
{
var builder = new RequestUriBuilder(Settings.QueueEndpoint);
builder.AddSegment(_queueName);
builder.AddSegment("messages");
builder.AddParameter(ProtocolConstants.QueryParameters.NumOfMessages, _numOfMessages.ToString());
builder.AddParameter(ProtocolConstants.QueryParameters.VisibilityTimeout, _visibilityTimeout.ToString());
if (_messageTtl.HasValue)
{
builder.AddParameter(ProtocolConstants.QueryParameters.MessageTTL, _messageTtl.Value.ToString());
}
return(builder);
}
public static AuthenticationResult Login(ApiConfiguration configuration, HttpClient httpClient, string username, string password)
{
var requestUri = RequestUriBuilder.Build(configuration, "api/account/login");
var body = PostBodyBuilder.ConstructBody(new LoginInformation(username, password));
var response = httpClient.PostAsync(requestUri, body).Result;
if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Unauthorized)
{
var errorText = response.Content.ReadAsStringAsync().Result;
throw new ApiException(response.StatusCode, errorText);
}
var json = response.Content.ReadAsStringAsync().Result;
var authenticationResult = ConfiguredJsonSerializer.Deserialize <AuthenticationResult>(json);
return(authenticationResult);
}
public async Task <string> GetDarcVersionAsync(
CancellationToken cancellationToken = default
)
{
const string apiVersion = "2019-01-16";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/assets/darc-version",
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Get;
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnGetDarcVersionFailed(_req, _res).ConfigureAwait(false);
}
if (_res.ContentStream == null)
{
await OnGetDarcVersionFailed(_req, _res).ConfigureAwait(false);
}
using (var _reader = new StreamReader(_res.ContentStream))
{
var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
var _body = Client.Deserialize <string>(_content);
return(_body);
}
}
}
}
