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));
}