gistfile1.cs

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Salesforce.Common.Models;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Salesforce.Common
{
    public class ServiceHttpClient : IServiceHttpClient
    {
        private readonly string _instanceUrl;
        private readonly string _apiVersion;
        private readonly string _userAgent;
        private readonly string _accessToken;

        
        private readonly HttpClient _httpClient;

        public ServiceHttpClient(string instanceUrl, string apiVersion, string accessToken,
            Func<HttpClient> builder = null) : this(instanceUrl, apiVersion, accessToken, "common-libraries-dotnet", builder)
        {
        }

        public ServiceHttpClient(string instanceUrl, string apiVersion, string accessToken, string userAgent = "common-libraries-dotnet", Func<HttpClient> builder = null)
        {
            _instanceUrl = instanceUrl;
            _apiVersion = apiVersion;
            _accessToken = accessToken;
            _userAgent = userAgent;

            _httpClient = builder == null ? new HttpClient() : builder();

            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _accessToken);
            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(string.Concat(_userAgent, "/", _apiVersion));

        }

        public async Task<T> HttpGet<T>(string urlSuffix)
        {
            var request = HttpGetCreateRequest(urlSuffix);
            var responseMessage = await _httpClient.SendAsync(request);
            return await HttpGetHandleResponse<T>(responseMessage);
        }


        public async Task<T> HttpGet<T>(string urlSuffix, string nodeName)
        {
            var request = HttpGetCreateRequest(urlSuffix);
            var responseMessage = await _httpClient.SendAsync(request);
            return await HttpGetHandleResponse<T>(nodeName, responseMessage);
        }

        public async Task<T> HttpPost<T>(object inputObject, string urlSuffix)
        {
            var request = HttpPostCreateRequest(inputObject, urlSuffix);
            var responseMessage = await _httpClient.SendAsync(request);
            return await HttpPostHandleResponse<T>(responseMessage);
        }

        public async Task<bool> HttpPatch(object inputObject, string urlSuffix)
        {
            var request = HttpPatchCreateRequest(inputObject, urlSuffix);
            var responseMessage = await _httpClient.SendAsync(request);
            return await HttpPatchHandleResponse(responseMessage);
        }

        public async Task<bool> HttpDelete(string urlSuffix)
        {
            var request = HttpDeleteCreateRequest(urlSuffix);
            var responseMessage = await _httpClient.SendAsync(request);
            return await HttpDeleteHandleResponse(responseMessage);
        }

        public HttpRequestMessage HttpGetCreateRequest(string urlSuffix)
        {
            var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion);
            var request = new HttpRequestMessage()
            {
                RequestUri = new Uri(url),
                Method = HttpMethod.Get
            };

            return request;
        }

        public HttpRequestMessage HttpPostCreateRequest(object inputObject, string urlSuffix)
        {
            var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion);

            var request = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri(url)
            };

            var json = JsonConvert.SerializeObject(inputObject, Formatting.None,
                new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
            request.Content = new StringContent(json, Encoding.UTF8, "application/json");
            return request;
        }

        public HttpRequestMessage HttpPatchCreateRequest(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");
            return request;
        }

        public HttpRequestMessage HttpDeleteCreateRequest(string urlSuffix)
        {
            var url = Common.FormatUrl(urlSuffix, _instanceUrl, _apiVersion);

            var request = new HttpRequestMessage()
            {
                RequestUri = new Uri(url),
                Method = HttpMethod.Delete
            };
            return request;
        }


        public static async Task<T> HttpGetHandleResponse<T>(HttpResponseMessage responseMessage)
        {
            var response = await responseMessage.Content.ReadAsStringAsync();

            if (responseMessage.IsSuccessStatusCode)
            {
                var jObject = JObject.Parse(response);

                var r = JsonConvert.DeserializeObject<T>(jObject.ToString());
                return r;
            }

            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response);
            throw new ForceException(errorResponse.errorCode, errorResponse.message);
        }


        public static async Task<T> HttpGetHandleResponse<T>(string nodeName, HttpResponseMessage responseMessage)
        {
            var response = await responseMessage.Content.ReadAsStringAsync();

            if (responseMessage.IsSuccessStatusCode)
            {
                var jObject = JObject.Parse(response);
                var jToken = jObject.GetValue(nodeName);

                var r = JsonConvert.DeserializeObject<T>(jToken.ToString());
                return r;
            }

            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response);
            throw new ForceException(errorResponse.errorCode, errorResponse.message);
        }


        public static async Task<T> HttpPostHandleResponse<T>(HttpResponseMessage responseMessage)
        {
            var response = await responseMessage.Content.ReadAsStringAsync();

            if (responseMessage.IsSuccessStatusCode)
            {
                var r = JsonConvert.DeserializeObject<T>(response);
                return r;
            }

            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response);
            throw new ForceException(errorResponse.message, errorResponse.errorCode);
        }


        public static async Task<bool> HttpPatchHandleResponse(HttpResponseMessage responseMessage)
        {
            if (responseMessage.IsSuccessStatusCode)
            {
                return true;
            }

            var response = await responseMessage.Content.ReadAsStringAsync();
            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response);
            throw new ForceException(errorResponse.error, errorResponse.error_description);
        }



        public static async Task<bool> HttpDeleteHandleResponse(HttpResponseMessage responseMessage)
        {
            if (responseMessage.IsSuccessStatusCode)
            {
                return true;
            }

            var response = await responseMessage.Content.ReadAsStringAsync();
            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response);
            throw new ForceException(errorResponse.error, errorResponse.error_description);
        }

    }
}