private async Task<HttpCall> SendAsync(RestRequest request, bool retryInvalidToken)
{
var url = _instanceUrl + request.Path;
var headers = request.AdditionalHeaders != null
? new HttpCallHeaders(_accessToken, request.AdditionalHeaders)
: new HttpCallHeaders(_accessToken, new Dictionary<string, string>());
var call =
await
new HttpCall(request.Method, headers, url, request.RequestBody, request.ContentType).ExecuteAsync()
.ConfigureAwait(false);
if (call.StatusCode != HttpStatusCode.Unauthorized && call.StatusCode != HttpStatusCode.Forbidden)
{
return call;
}
if (!retryInvalidToken || _accessTokenProvider == null) return call;
var newAccessToken = await _accessTokenProvider();
if (newAccessToken == null)
{
return call;
}
_accessToken = newAccessToken;
call = await SendAsync(request, false);
// Done
return call;
}
public async void SendAsync(RestRequest request, AsyncRequestCallback callback)
{
RestResponse result = await SendAsync(request).ConfigureAwait(false);
if (callback != null)
{
callback(result);
}
}
public void TestAdditionalHeaders()
{
Dictionary<string, string> headers = new Dictionary<string, string>() {{"X-Foo", "RestRequestName"}};
RestRequest request = new RestRequest(RestMethod.GET, "/my/foo/", null, ContentType.NONE, headers);
Assert.AreEqual(RestMethod.GET, request.Method, "Wrong method");
Assert.AreEqual(ContentType.NONE, request.ContentType, "Wrong content type");
Assert.AreEqual("/my/foo/", request.Path, "Wrong path");
Assert.IsNull(request.Body, "Wrong body");
Assert.AreEqual(headers, request.AdditionalHeaders, "Wrong headers");
}
private HttpCall SendSync(RestRequest request, bool retryInvalidToken)
{
string url = _instanceUrl + request.Path;
Dictionary<string, string> headers = new Dictionary<string, string>() {};
if (_accessToken != null)
{
headers["Authorization"] = "Bearer " + _accessToken;
}
if (request.AdditionalHeaders != null)
{
headers.Concat(request.AdditionalHeaders);
}
HttpCall call = new HttpCall(request.Method, headers, url, request.Body, request.ContentType).Execute().Result;
if (!call.HasResponse)
{
throw call.Error;
}
if (call.StatusCode == HttpStatusCode.Unauthorized)
{
if (retryInvalidToken && _accessTokenProvider != null)
{
string newAccessToken = _accessTokenProvider().Result;
if (newAccessToken != null)
{
_accessToken = newAccessToken;
call = SendSync(request, false);
}
}
}
// Done
return call;
}
public static async Task<IdentityResponse> CallIdentityServiceAsync(string idUrl, IRestClient client)
{
var request = new RestRequest(HttpMethod.Get, new Uri(idUrl).AbsolutePath);
var response = await client.SendAsync(request);
if (response.Success)
{
LoggingService.Log("success", LoggingLevel.Verbose);
return JsonConvert.DeserializeObject<IdentityResponse>(response.AsString);
}
else
{
LoggingService.Log("Error occured:", LoggingLevel.Critical);
LoggingService.Log(response.Error, LoggingLevel.Critical);
}
throw response.Error;
}
public async Task<IRestResponse> SendAsync(RestRequest request)
{
var result = await SendAsync(request, true);
return new RestResponse(result);
}
public async void SendAsync(RestRequest request, AsyncRequestCallback callback)
{
var result = await SendAsync(request).ConfigureAwait(false);
callback?.Invoke(result);
}
public override async Task<JArray> ContinueFetch(SyncManager syncManager)
{
if (String.IsNullOrWhiteSpace(NextRecordsUrl))
{
return null;
}
var request = new RestRequest(HttpMethod.Get, NextRecordsUrl);
var response = await syncManager.SendRestRequest(request);
JObject responseJson = response.AsJObject;
var records = responseJson.ExtractValue<JArray>(Constants.Records);
return records;
}
public RestResponse SendSync(RestRequest request)
{
return new RestResponse(SendSync(request, true));
}
public async Task<RestResponse> SendAsync(RestRequest request)
{
return await Task.Factory.StartNew(() => SendSync(request));
}
public void SendAsync(RestRequest request, AsyncRequestCallback callback)
{
SendAsync(request).ContinueWith((t) => callback(t.Result));
}
public void TestAdditionalHeaders()
{
var headers = new Dictionary<string, string> {{"X-Foo", "RestRequestName"}};
var request = new RestRequest(HttpMethod.Get, "/my/foo/", null, ContentTypeValues.None, headers);
Assert.AreEqual(HttpMethod.Get, request.Method, "Wrong method");
Assert.AreEqual(ContentTypeValues.None, request.ContentType, "Wrong content type");
Assert.AreEqual("/my/foo/", request.Path, "Wrong path");
Assert.IsNull(request.RequestBody, "Wrong body");
Assert.AreEqual(headers, request.AdditionalHeaders, "Wrong headers");
}
public static async Task<IdentityResponse> CallIdentityService(string idUrl, RestClient client)
{
var request = new RestRequest(HttpMethod.Get, new Uri(idUrl).AbsolutePath);
RestResponse response = await client.SendAsync(request);
if (response.Success)
{
PlatformAdapter.SendToCustomLogger("OAuth2.CallIdentityService - success", LoggingLevel.Verbose);
return JsonConvert.DeserializeObject<IdentityResponse>(response.AsString);
}
else
{
PlatformAdapter.SendToCustomLogger("OAuth2.CallIdentityService - Error occured:", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(response.Error, LoggingLevel.Critical);
}
throw response.Error;
}
private async Task<HttpCall> Send(RestRequest request, bool retryInvalidToken)
{
string url = _instanceUrl + request.Path;
var headers = request.AdditionalHeaders != null ? new HttpCallHeaders(_accessToken, request.AdditionalHeaders) : new HttpCallHeaders(_accessToken, new Dictionary<string, string>());
HttpCall call =
await
new HttpCall(request.Method, headers, url, request.RequestBody, request.ContentType).Execute()
.ConfigureAwait(false);
if (!call.HasResponse)
{
throw call.Error;
}
if (call.StatusCode == HttpStatusCode.Unauthorized || call.StatusCode == HttpStatusCode.Forbidden)
{
if (retryInvalidToken && _accessTokenProvider != null)
{
string newAccessToken = await _accessTokenProvider();
if (newAccessToken != null)
{
_accessToken = newAccessToken;
call = await Send(request, false);
}
}
}
// Done
return call;
}
public async Task<RestResponse> SendAsync(RestRequest request)
{
HttpCall result = await Send(request, true);
return new RestResponse(result);
}