public async Task <T> HttpPostAsync <T>(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new CreateableContractResolver() }); var content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await _httpClient.PostAsync(new Uri(url), content).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var r = JsonConvert.DeserializeObject <T>(response); return(r); } var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); }
public async Task <T> HttpGetAsync <T, TErrorResponse>(string urlSuffix) where TErrorResponse : IErrorResponse { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(await HttpGetAsync <T, TErrorResponse>(url)); }
public async Task <bool> HttpDeleteAsync(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = HttpMethod.Delete }; if (request.RequestUri.Scheme == "https") { System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls; } var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { return(true); } var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); }
public async Task <T> HttpPostAsync <T>(object inputObject, string urlSuffix) { var uri = Common.FormatUrl(urlSuffix, _instanceUrl, ApiVersion); var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new CreateableContractResolver(), DateFormatString = DateFormat }); var content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await _httpClient.PostAsync(uri, content).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var r = JsonConvert.DeserializeObject <T>(response); return(r); } if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.ToString().Contains("application/json")) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } else { throw new ForceException(Error.NonJsonErrorResponse, response); } }
public async Task <bool> HttpDeleteAsync(string urlSuffix) { var uri = Common.FormatUrl(urlSuffix, _instanceUrl, ApiVersion); var request = new HttpRequestMessage { RequestUri = uri, Method = HttpMethod.Delete }; var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { return(true); } var response = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.ToString().Contains("application/json")) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } else { throw new ForceException(Error.NonJsonErrorResponse, response); } }
public async Task <bool> HttpPatchAsync(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage() { RequestUri = new Uri(url), Method = new HttpMethod("PATCH") }; var json = JsonConvert.SerializeObject(inputObject); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { return(true); } var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].errorCode, errorResponse[0].message); }
public async Task <IList <T> > HttpGetAsync <T>(string urlSuffix, string nodeName) { string next = null; var records = new List <T>(); var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); do { if (next != null) { url = Common.FormatUrl(string.Format("query/{0}", next.Split('/').Last()), InstanceUrl, ApiVersion); } try { var response = await HttpGetAsync(url); var jObject = JObject.Parse(response); var jToken = jObject.GetValue(nodeName); next = (jObject.GetValue("nextRecordsUrl") != null) ? jObject.GetValue("nextRecordsUrl").ToString() : null; records.AddRange(JsonConvert.DeserializeObject <IList <T> >(jToken.ToString())); } catch (BaseHttpClientException e) { throw ParseForceException(e.Message); } }while (!string.IsNullOrEmpty(next)); return(records); }
public async Task <T> HttpPostAsync <T>(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var r = await this.HttpPostAsync <T>(inputObject, new Uri(url)); return(r); }
public async Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix) { var uri = Common.FormatUrl(urlSuffix, _instanceUrl, ApiVersion); var request = new HttpRequestMessage { RequestUri = uri, Method = new HttpMethod("PATCH") }; var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new UpdateableContractResolver(), DateFormatString = DateFormat }); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { if (responseMessage.StatusCode != System.Net.HttpStatusCode.NoContent) { var response = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); var r = JsonConvert.DeserializeObject <SuccessResponse>(response); return(r); } var success = new SuccessResponse { Id = "", Errors = "", Success = true }; return(success); } var error = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.ToString().Contains("application/json")) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(error); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } else { throw new ForceException(Error.NonJsonErrorResponse, error); } }
public async Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix, bool ignoreNull) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); if (ignoreNull == true) { return(await HttpPatchAsync(inputObject, url)); } else { return(await HttpPatchAsync(inputObject, url, NullValueHandling.Include)); } // return await HttpPatchAsync(inputObject, url, ignoreNull); }
public async Task <IList <T> > HttpGetAsync <T>(string urlSuffix, string nodeName) { string next = null; string response = null; var records = new List <T>(); var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); try { do { if (next != null) { url = Common.FormatUrl(string.Format("query/{0}", next.Split('/').Last()), _instanceUrl, _apiVersion); } var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = HttpMethod.Get }; if (request.RequestUri.Scheme == "https") { System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls; } var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var jObject = JObject.Parse(response); var jToken = jObject.GetValue(nodeName); next = (jObject.GetValue("nextRecordsUrl") != null) ? jObject.GetValue("nextRecordsUrl").ToString() : null; records.AddRange(JsonConvert.DeserializeObject <IList <T> >(jToken.ToString())); } } while (!string.IsNullOrEmpty(next)); return((IList <T>)records); } catch (ForceException) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } }
public async Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = new HttpMethod("PATCH") }; var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { ContractResolver = new UpdateableContractResolver() }); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); if (request.RequestUri.Scheme == "https") { System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls; } var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { if (responseMessage.StatusCode != System.Net.HttpStatusCode.NoContent) { var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); var r = JsonConvert.DeserializeObject <SuccessResponse>(response); return(r); } var success = new SuccessResponse { Id = "", Errors = "", Success = "true" }; return(success); } var error = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(error); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); }
public async Task <T> HttpBinaryDataPostAsync <T>(string urlSuffix, object inputObject, byte[] fileContents, string headerName, string fileName) { var uri = Common.FormatUrl(urlSuffix, _instanceUrl, ApiVersion); var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, }); var content = new MultipartFormDataContent(); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); stringContent.Headers.Add("Content-Disposition", "form-data; name=\"json\""); content.Add(stringContent); var byteArrayContent = new ByteArrayContent(fileContents); byteArrayContent.Headers.Add("Content-Type", "application/octet-stream"); byteArrayContent.Headers.Add("Content-Disposition", String.Format("form-data; name=\"{0}\"; filename=\"{1}\"", headerName, fileName)); content.Add(byteArrayContent, headerName, fileName); var responseMessage = await _httpClient.PostAsync(uri, content).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var r = JsonConvert.DeserializeObject <T>(response); return(r); } if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.ToString().Contains("application/json")) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } else { throw new ForceException(Error.NonJsonErrorResponse, response); } }
public async Task <T> HttpPostAsyncWithHeaders <T>(object inputObject, string urlSuffix, IDictionary <string, string> headers) { var uri = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); var request = new HttpRequestMessage { RequestUri = uri, Method = new HttpMethod("POST"), }; if (headers != null) { foreach (var h in headers) { request.Headers.Add(h.Key, h.Value); } } var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new CreateableContractResolver(), DateFormatString = DateFormat }); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await HttpClient.SendAsync(request).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var r = JsonConvert.DeserializeObject <T>(response); return(r); } var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); }
public async Task <T> HttpGetAsync <T>(string urlSuffix) { var uri = Common.FormatUrl(urlSuffix, _instanceUrl, ApiVersion); var request = new HttpRequestMessage { RequestUri = uri, Method = HttpMethod.Get }; var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsDecompressedStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var jToken = JToken.Parse(response); if (jToken.Type == JTokenType.Array) { var jArray = JArray.Parse(response); var r = JsonConvert.DeserializeObject <T>(jArray.ToString()); return(r); } else { var jObject = JObject.Parse(response); var r = JsonConvert.DeserializeObject <T>(jObject.ToString()); return(r); } } if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.ToString().Contains("application/json")) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); } else { throw new ForceException(Error.NonJsonErrorResponse, response); } }
public async Task <T> HttpGetAsync <T>(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = HttpMethod.Get }; if (request.RequestUri.Scheme == "https") { System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls; } var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { var jToken = JToken.Parse(response); if (jToken.Type == JTokenType.Array) { var jArray = JArray.Parse(response); var r = JsonConvert.DeserializeObject <T>(jArray.ToString()); return(r); } else { var jObject = JObject.Parse(response); var r = JsonConvert.DeserializeObject <T>(jObject.ToString()); return(r); } } var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].ErrorCode, errorResponse[0].Message); }
public async Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage() { RequestUri = new Uri(url), Method = new HttpMethod("PATCH") }; var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { ContractResolver = new UpdateableContractResolver() }); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { if (!string.IsNullOrEmpty(response)) { var r = JsonConvert.DeserializeObject <SuccessResponse>(response); return(r); } var success = new SuccessResponse { id = "", errors = "", success = "true" }; return(success); } var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].errorCode, errorResponse[0].message); }
public async Task <T> HttpBinaryDataPostAsync <T, TErrorResponse>(string urlSuffix, object inputObject, byte[] fileContents, string headerName, string fileName) where TErrorResponse : IErrorResponse { // BRAD: I think we should probably, in time, refactor multipart and binary support to the BaseHttpClient. // For now though, I just left this in here. var uri = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); var json = JsonConvert.SerializeObject(inputObject, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); var content = new MultipartFormDataContent(); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); stringContent.Headers.Add("Content-Disposition", "form-data; name=\"json\""); content.Add(stringContent); var byteArrayContent = new ByteArrayContent(fileContents); byteArrayContent.Headers.Add("Content-Type", "application/octet-stream"); byteArrayContent.Headers.Add("Content-Disposition", string.Format("form-data; name=\"{0}\"; filename=\"{1}\"", headerName, fileName)); content.Add(byteArrayContent, headerName, fileName); var responseMessage = await HttpClient.PostAsync(uri, content).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <T>(response)); } throw ParseForceException <TErrorResponse>(response, responseMessage.StatusCode); }
public async Task <System.IO.Stream> HttpGetBlobAsync(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); var request = new HttpRequestMessage { RequestUri = url, Method = HttpMethod.Get }; var responseMessage = await HttpClient.SendAsync(request).ConfigureAwait(false); var response = await responseMessage.Content.ReadAsStreamAsync(); if (responseMessage.IsSuccessStatusCode) { return(response); } else { return(new System.IO.MemoryStream()); } }
public async Task <bool> HttpDeleteAsync(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage() { RequestUri = new Uri(url), Method = HttpMethod.Delete }; var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false); if (responseMessage.IsSuccessStatusCode) { return(true); } var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].errorCode, errorResponse[0].message); }
public async Task <T> HttpGetAsync <T>(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion); var request = new HttpRequestMessage() { RequestUri = new Uri(url), Method = HttpMethod.Get }; var responseMessage = await _httpClient.SendAsync(request); var response = await responseMessage.Content.ReadAsStringAsync(); if (responseMessage.IsSuccessStatusCode) { var jToken = JToken.Parse(response); if (jToken.Type == JTokenType.Array) { var jArray = JArray.Parse(response); var r = JsonConvert.DeserializeObject <T>(jArray.ToString()); return(r); } else { var jObject = JObject.Parse(response); var r = JsonConvert.DeserializeObject <T>(jObject.ToString()); return(r); } } var errorResponse = JsonConvert.DeserializeObject <ErrorResponses>(response); throw new ForceException(errorResponse[0].errorCode, errorResponse[0].message); }
// DELETE public async Task <bool> HttpDeleteAsync(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(await HttpDeleteAsync(url)); }
// POST public Task <T> HttpPostAsync <T>(object inputObject, string urlSuffix, CancellationToken token) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(HttpPostAsync <T>(inputObject, url, token)); }
// PATCH public Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix, CancellationToken token) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(HttpPatchAsync(inputObject, url, token)); }
// DELETE public Task <bool> HttpDeleteAsync(string urlSuffix, CancellationToken token) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(HttpDeleteAsync(url, token)); }
// GET public Task <T> HttpGetAsync <T>(string urlSuffix, CancellationToken token) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(HttpGetAsync <T>(url, token)); }
// POST public async Task <CompositeResponse> HttpCompositeAsync(CompositeRequest request) { var url = Common.FormatUrl("composite/", InstanceUrl, ApiVersion); return(await HttpPostAsync <CompositeResponse>(request, url)); }
public async Task <T> HttpPostAsync <T>(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(await HttpPostAsync <T>(inputObject, url)); }
// PATCH public async Task <SuccessResponse> HttpPatchAsync(object inputObject, string urlSuffix) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(await HttpPatchAsync(inputObject, url)); }
// GET public async Task <T> HttpGetAsync <T>(string urlSuffix) { var url = Common.FormatUrl(urlSuffix, InstanceUrl, ApiVersion); return(await HttpGetAsync <T>(url)); }