public static async Task<RootObject> Get()
{
var serializer = new SimplyMobile.Text.ServiceStack.JsonSerializer ();
var webClient = new JsonClient (serializer);
var response = await webClient.GetAsync<RootObject>("http://www.reddit.com/r/all.json", Format.Json);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Value;
}
else
{
System.Diagnostics.Debug.WriteLine (response.Content);
}
var serializer2 = new SimplyMobile.Text.JsonNet.JsonSerializer ();
webClient = new JsonClient(serializer2);
response = await webClient.GetAsync<RootObject>("http://www.reddit.com/r/all.json", Format.Json);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Value;
}
else
{
System.Diagnostics.Debug.WriteLine (response.Content);
}
return null;
}
public void Given_Valid_Url_Api_Returns_Deserialized_Items()
{
var url = "http://api.dotnetgroup.dev/v1/stream";
var items = new JsonClient().Get<IEnumerable<Item>>(url);
CollectionAssert.IsNotEmpty(items);
}
public void Given_Valid_Url_Api_Returns_Serialized_Items()
{
var url = "http://api.dotnetgroup.dev/v1/stream";
var json = new JsonClient().Get(url);
CollectionAssert.IsNotEmpty(json);
}
/// <summary>
/// Returns details about a specific Docker network.
/// </summary>
/// <param name="nameOrId">The network name or ID.</param>
/// <param name="cancellationToken">Optional cancellation token.</param>
/// <returns>A <see cref="DockerNetwork"/> instance.</returns>
public async Task <DockerNetwork> NetworkInspect(string nameOrId, CancellationToken cancellationToken = default)
{
await SyncContext.Clear;
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(nameOrId), nameof(nameOrId));
var response = await JsonClient.GetAsync(GetUri("networks", nameOrId), cancellationToken : cancellationToken);
return(new DockerNetwork(response.AsDynamic()));
}
public async Task WithValidParams_ReturnsTrue()
{
const string status = "OK";
var basicJson = BasicJson.GetDefault();
var data = await JsonClient.Post <BasicJson>($"{DefaultHttp}{Api}/WithValidParams", basicJson);
Assert.IsNotNull(data);
Assert.AreEqual(status, data.StringData);
}
private void ConfigureOperation(string operation, bool active)
{
JsonClient.Post(new ConfigureOperationRequest
{
Service = Capabilities.Service,
Version = Capabilities.Version,
Operation = operation,
Active = active
});
}
public void ClearDatasource()
{
using (SosScope())
{
Log.Info("Clearing the SOS database ...");
JsonClient.Post(new ClearDatasourceRequest());
}
GetCapabilities();
}
public void ActionRetryTest()
{
Assert.Throws <AggregateException>(() =>
{
var action =
new Action(() => JsonClient.GetString("http://accesscore.azurewebsites.net/api/token").Wait());
action.Retry();
});
}
public async Task OptionsAsync_Dynamic_NotJson()
{
// Ensure that OPTIONS returning non-JSON returns a NULL dynamic document.
RequestDoc requestDoc = null;
using (new MockHttpServer(baseUri,
async context =>
{
var request = context.Request;
var response = context.Response;
if (request.Method != "OPTIONS")
{
response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
return;
}
if (request.Path.ToString() != "/info")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
requestDoc = NeonHelper.JsonDeserialize <RequestDoc>(request.GetBodyText());
var output = new ReplyDoc()
{
Value1 = "Hello World!"
};
response.ContentType = "application/not-json";
await response.WriteAsync(NeonHelper.JsonSerialize(output));
}))
{
using (var jsonClient = new JsonClient())
{
var doc = new RequestDoc()
{
Operation = "FOO",
Arg0 = "Hello",
Arg1 = "World"
};
var reply = (await jsonClient.OptionsAsync(baseUri + "info", doc)).AsDynamic();
Assert.Equal("FOO", requestDoc.Operation);
Assert.Equal("Hello", requestDoc.Arg0);
Assert.Equal("World", requestDoc.Arg1);
Assert.Null(reply);
}
};
}
public async Task PostUnsafeAsync()
{
// Ensure that POST returning an explict type works.
RequestDoc requestDoc = null;
using (new MockHttpServer(baseUri,
async context =>
{
var request = context.Request;
var response = context.Response;
if (request.Method != "POST")
{
response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
return;
}
if (request.Path.ToString() != "/info")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
requestDoc = NeonHelper.JsonDeserialize <RequestDoc>(request.GetBodyText());
var output = new ReplyDoc()
{
Value1 = "Hello World!"
};
response.ContentType = "application/json";
await response.WriteAsync(NeonHelper.JsonSerialize(output));
}))
{
using (var jsonClient = new JsonClient())
{
var doc = new RequestDoc()
{
Operation = "FOO",
Arg0 = "Hello",
Arg1 = "World"
};
var reply = (await jsonClient.PostUnsafeAsync(baseUri + "info", doc)).As <ReplyDoc>();
Assert.Equal("Hello World!", reply.Value1);
Assert.Equal("FOO", requestDoc.Operation);
Assert.Equal("Hello", requestDoc.Arg0);
Assert.Equal("World", requestDoc.Arg1);
}
};
}
public XblIdentityCache(
ILoggerFactory loggerFactory,
IRedisClientsManager redisClientsManager,
TokenClient tokenClient
)
{
_logger = loggerFactory.CreateLogger(typeof(XblIdentityCache));
_redisClientsManager = redisClientsManager;
_tokenClient = tokenClient;
_client = new JsonClient("https://profile.xboxlive.com");
}
//---------------------------------------------------------------------
// Implements Docker Network related operations.
/// <summary>
/// Creates a Docker network.
/// </summary>
/// <param name="network">The network details.</param>
/// <param name="cancellationToken">Optional cancellation token.</param>
/// <returns>A <see cref="NetworkCreateResponse"/>.</returns>
public async Task <NetworkCreateResponse> NetworkCreateAsync(DockerNetwork network, CancellationToken cancellationToken = default)
{
Covenant.Requires <ArgumentNullException>(network != null);
// $todo(jeff.lill):
//
// Ipam.Config settings aren't working. Looks like I need to wrap them into
// a JSON array before sending. It's a bit weird.
return(new NetworkCreateResponse(await JsonClient.PostAsync(GetUri("networks", "create"), network, cancellationToken: cancellationToken)));
}
private async Task ExecuteGetVersion(JsonClient client, bool isInternal)
{
var result = await Assert_NotTimedOut(client.Call(new GetVersion {
IsInternal = isInternal
}), "StressTest.GetVersion");
var expected = isInternal ? "Version 0.01-alpha, build 12345, by yallie" : "0.01-alpha";
Assert.NotNull(result);
Assert.AreEqual(expected, result.Version);
}
public async Task PutDynamicAsync()
{
// Ensure that PUT sending a dynamic document works.
RequestDoc requestDoc = null;
using (new MockHttpServer(baseUri,
context =>
{
var request = context.Request;
var response = context.Response;
if (request.Method != "PUT")
{
response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
return;
}
if (request.Path.ToString() != "/info")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
requestDoc = NeonHelper.JsonDeserialize <RequestDoc>(request.GetBodyText());
var output = new ReplyDoc()
{
Value1 = "Hello World!"
};
response.ContentType = "application/json";
response.Write(NeonHelper.JsonSerialize(output));
}))
{
using (var jsonClient = new JsonClient())
{
dynamic doc = new ExpandoObject();
doc.Operation = "FOO";
doc.Arg0 = "Hello";
doc.Arg1 = "World";
var reply = (await jsonClient.PutAsync(baseUri + "info", doc)).As <ReplyDoc>();
Assert.Equal("FOO", requestDoc.Operation);
Assert.Equal("Hello", requestDoc.Arg0);
Assert.Equal("World", requestDoc.Arg1);
Assert.Equal("Hello World!", reply.Value1);
}
}
}
public ActionResult Check()
{
var timer = new Stopwatch();
timer.Start();
var check = new Check
{
Groups = MvcApplication.Configuration.Groups.Select(cfg => new Group {
Name = cfg.Name
}).ToList()
};
Parallel.ForEach(MvcApplication.Configuration.Groups, cfg =>
{
var group = check.Groups.Single(g => g.Name == cfg.Name);
var nodes = MvcApplication.Configuration.Nodes.First(nc => nc.Name == cfg.NodeConfiguration).Hosts;
group.Nodes = nodes.Select(host => new Node {
Name = host
}).ToList();
Parallel.ForEach(nodes, node =>
{
var viewNode = group.Nodes.Single(vn => vn.Name == node);
var nodeTime = new Stopwatch();
nodeTime.Start();
try
{
var restClient = new JsonClient(useISODates: true);
var appUri = new Uri($"http://{node}{cfg.Url}");
var jsonVersion = GetVersion(restClient, appUri);
viewNode.Version = new Version {
BuildTime = jsonVersion.BuildTime, GitHash = jsonVersion.GitSha
};
if (!string.IsNullOrEmpty(cfg.HealthCheck))
{
viewNode.CheckUri = new Uri($"{appUri}{cfg.HealthCheck}");
var checks = GetChecks(restClient, viewNode.CheckUri);
viewNode.CheckPassed = checks.All(c => c.Passed.GetValueOrDefault(true));
}
}
catch (Exception e)
{
viewNode.CheckPassed = false;
viewNode.Exception = e;
}
nodeTime.Stop();
viewNode.Time = nodeTime.Elapsed;
});
});
timer.Stop();
check.Duration = timer.Elapsed;
return(PartialView(check));
}
public async Task PostJsonData()
{
var model = new Person()
{
Key = 10, Name = "Test"
};
var result = await JsonClient.Post <Person>(WebServerUrl + TestController.GetPath, model);
Assert.IsNotNull(result);
Assert.AreEqual(result.Name, model.Name);
}
public async Task WithValidParamsAndAuthorizationToken_ReturnsTrue()
{
var data = await JsonClient.Post(
new Uri($"{DefaultHttp}{Api}/WithValidParamsAndAuthorizationToken"),
BasicJson.GetDefault(),
AuthorizationToken);
Assert.IsNotNull(data);
Assert.IsTrue(data !.ContainsKey(Authorization));
Assert.AreEqual($"Bearer {AuthorizationToken}", data[Authorization]);
}
/// <inheritdoc/>
public override void Reset()
{
if (!IsDisposed)
{
JsonClient.Dispose();
WebHost.StopAsync().Wait();
JsonClient = null;
WebHost = null;
}
}
public WaypointClient(TokenClient tokenClient, IdentityClient identityClient, S3Client s3Client)
: base(s3Client)
{
this._tokenClient = tokenClient;
this._transpiler = new Transpiler();
this._enricher = new Enricher(identityClient);
this._presenceClient = new JsonClient(presenceUrl);
this._statsClient = new JsonClient(statsUrl);
this._settingsClient = new JsonClient(settingsUrl);
this._optionsClient = new JsonClient(optionsUrl);
}
public async Task <GetFileSteamResponse> GetLogoInfoAsync(long id)
{
var parameters = new Dictionary <string, string>
{
{ "ugcid", id.ToString(CultureInfo.InvariantCulture) },
{ "appid", "570" }
};
var requestUrl = GetRequestUrl("ISteamRemoteStorage", "GetUGCFileDetails", parameters);
return(await JsonClient.GetAsync <GetFileSteamResponse>(requestUrl));
}
/// <summary>
/// Private constructor.
/// </summary>
/// <param name="uri">The Vault server URI.</param>
private VaultClient(Uri uri)
{
var handler = new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
};
jsonClient = new JsonClient(handler, disposeHandler: true);
jsonClient.SafeRetryPolicy = new ExponentialRetryPolicy(TransientDetector.NetworkOrHttp);
jsonClient.BaseAddress = uri;
}
public async Task <GetTeamInfoSteamResponse> GetTeamInfoAsync(long teamId)
{
var parameters = new Dictionary <string, string>
{
{ "teams_requested", "1" },
{ "start_at_team_id", teamId.ToString() }
};
var requestUrl = GetRequestUrl("IDOTA2Match_570", "GetTeamInfoByTeamID", parameters);
return(await JsonClient.GetAsync <GetTeamInfoSteamResponse>(requestUrl));
}
/// <summary>
/// Get field and other metadata for an object.
/// <para>Use the SObject Describe resource to retrieve all the metadata for an object, including information about each field, URLs, and child relationships.</para>
/// </summary>
/// <param name="objectTypeName">SObject name, e.g. Account</param>
/// <returns>Returns SObjectMetadataAll with full object meta including field metadata</returns>
public async Task <SObjectDescribeFull> GetObjectDescribe(string objectTypeName)
{
var uri = UriFormatter.SObjectDescribe(_instanceUrl, _apiVersion, objectTypeName);
using (var httpClient = new HttpClient())
{
JsonClient client = new JsonClient(_accessToken, httpClient);
return(await client.HttpGetAsync <SObjectDescribeFull>(uri));
}
}
public TokenClient(string baseUrl, string key)
{
var options = new HttpClientOptions
{
Headers = new Dictionary <string, string> {
{ "Authorization", $"bearer {key}" }
},
};
_client = new JsonClient(baseUrl, options);
}
/// <summary>
/// Lists information about limits in your org.
/// <para>This resource is available in REST API version 29.0 and later for API users with the View Setup and Configuration permission.</para>
/// </summary>
public async Task <OrganizationLimits> GetOrganizationLimits()
{
var uri = UriFormatter.Limits(_instanceUrl, _apiVersion);
using (var httpClient = new HttpClient())
{
JsonClient client = new JsonClient(_accessToken, httpClient);
return(await client.HttpGetAsync <OrganizationLimits>(uri));
}
}
/// <inheritdoc/>
public override void Reset()
{
if (!IsDisposed)
{
JsonClient?.Dispose();
WebHost?.StopAsync().WaitWithoutAggregate();
JsonClient = null;
WebHost = null;
}
}
public static IClientNetworkedDevice CreateFromJson(UniFiApi api, JsonClient client)
{
if (client.is_wired)
{
return(new WiredClientNetworkedDevice(api, client));
}
else
{
return(new WirelessClientNetworkedDevice(api, client));
}
}
public void RespectOptions()
{
var options = new Options
{
Timeout = TimeSpan.FromMilliseconds(2500),
};
var client = new JsonClient("https://example.com", options);
Assert.Equal(client.Client.Options.Timeout, options.Timeout);
}
public async Task WithValidParams_ReturnsTrue()
{
var responseObj = new Dictionary <string, object> {
{ AuthorizationToken, "123" }
};
var data = await JsonClient.Authenticate(new Uri($"{DefaultHttp}/Authenticate"), "admin", "password");
Assert.IsNotNull(data);
Assert.IsTrue(data !.ContainsKey(AuthorizationToken));
Assert.AreEqual(responseObj[AuthorizationToken], data[AuthorizationToken]);
}
public async Task PostAsync_Retry()
{
// Ensure that POST will retry after soft errors.
RequestDoc requestDoc = null;
var attemptCount = 0;
using (new MockHttpServer(baseUri,
async context =>
{
var request = context.Request;
var response = context.Response;
if (attemptCount++ == 0)
{
response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
return;
}
requestDoc = NeonHelper.JsonDeserialize <RequestDoc>(request.GetBodyText());
var output = new ReplyDoc()
{
Value1 = "Hello World!"
};
response.ContentType = "application/json";
await response.WriteAsync(NeonHelper.JsonSerialize(output));
}))
{
using (var jsonClient = new JsonClient())
{
var doc = new RequestDoc()
{
Operation = "FOO",
Arg0 = "Hello",
Arg1 = "World"
};
var reply = (await jsonClient.PostAsync(baseUri + "info", doc)).AsDynamic();
Assert.Equal("FOO", requestDoc.Operation);
Assert.Equal("Hello", requestDoc.Arg0);
Assert.Equal("World", requestDoc.Arg1);
Assert.Equal(2, attemptCount);
Assert.Equal("Hello World!", (string)reply.Value1);
}
};
}
/// <summary>
/// Get SObject by ID
/// </summary>
/// <param name="sObjectTypeName">SObject name, e.g. "Account"</param>
/// <param name="objectId">SObject ID</param>
/// <param name="fields">(optional) List of fields to retrieve, if not supplied, all fields are retrieved.</param>
public async Task <T> GetObjectById <T>(string sObjectTypeName, string objectId, List <string> fields = null)
{
Dictionary <string, string> headers = HeaderFormatter.SforceCallOptions(_clientName);
var uri = UriFormatter.SObjectRows(_instanceUrl, _apiVersion, sObjectTypeName, objectId, fields);
using (var httpClient = new HttpClient())
{
JsonClient client = new JsonClient(_accessToken, httpClient);
return(await client.HttpGetAsync <T>(uri, headers));
}
}
public async void RottenTomato()
{
var client = new JsonClient("https://beta.izooble.com");
var request = new StreamRequest
{
BeforeDate = "2014-06-12T19:07:09.771Z"
};
var result = await client.Get(request);
Assert.That(result.Reviews.Count(), Is.EqualTo(10));
}
public void Connect()
{
JsonClient?.Dispose();
JsonClient = new SdkServiceClient(HostUrl);
UserAgent = JsonClient.UserAgent;
GetCapabilities();
CreateAuthenticatedSession();
}
public JsonResponseStatusException(JsonClient jsonClient, string status)
: base($"{jsonClient.Uri} returned Error {status}")
{
this.Uri = jsonClient.Uri;
this.Status = status;
}
public void Setup()
{
this.Client = new JsonClient(Profile.GetActiveProfile().Uri);
}
public void TearDown()
{
this.Client = null;
}
private static string GetTitle(
this Torrent torrent,
JsonClient client)
{
return torrent.GetTitle(client.GetGroups, client.GetArtists);
}
