using System;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

}

​

public partial class TenantManagementApi : MicroserviceApi

{

    public TenantManagementApi(IHttpClientFactory httpClientFactory, IOptions<HostAddresses> addresses)

        : base(httpClientFactory, addresses.Value.TenantManagement)

        { }

}

​

    public partial class TenantManagementApi

    {

        public async Task<List<T>> GetAllCorporations<T>(Dictionary<string, string> queryParameters)

        {

            var url = BuildUrl(Endpoints.Corporations.All, routeParameters: null, queryParameters);

            return await GetAsync<List<T>>(url);

        }

​

        public async Task<T> GetCorporationById<T>(string corporationId, Dictionary<string, string> queryParameters)

        {

            var routeParameters = new Dictionary<string, string>

            {

                { "id", corporationId }

            };

​

            var url = BuildUrl(Endpoints.Corporations.ById, routeParameters, queryParameters);

            return await GetAsync<T>(url);

        }

​

        public async Task CreateCorporation(object corporation)

        {

            var url = BuildUrl(Endpoints.Corporations.All);

            await PostAsync(url, corporation);

        }

​

        public async Task UpdateCorporation(string corporationId, object corporation)

        {

            var routeParameters = new Dictionary<string, string>

            {

                { "id", corporationId }

            };

​

            var url = BuildUrl(Endpoints.Corporations.ById, routeParameters);

            await PutAsync(url, corporation);

        }

​

        public async Task DeleteCorporation(string corporationId, Dictionary<string, string> queryParameters)

        {

            var routeParameters = new Dictionary<string, string>

            {

                { "id", corporationId }

            };

​

            var url = BuildUrl(Endpoints.Corporations.ById, routeParameters, queryParameters);

            await DeleteAsync(url);

        }

    }

​

public abstract class MicroserviceApi

{

    private readonly IHttpClientFactory _httpClientFactory;

    private string baseURL;

​

        public MicroserviceApi(IHttpClientFactory httpClientFactory, string hostAddress)

        {

            _httpClientFactory = httpClientFactory;

            baseURL = hostAddress;

        }

​

        protected async Task<T> GetAsync<T>(string url)

        {

            var response = await Send(HttpMethod.Get, url);

            var content = await response.Content.ReadAsStringAsync();

            return JsonConvert.DeserializeObject<T>(content);

        }

​

        protected async Task PostAsync(string url, object content)

        {

            var response = await Send(HttpMethod.Post, url, content);

        }

​

        protected async Task PutAsync(string url, object content)

        {

            var response = await Send(HttpMethod.Put, url, content);

        }

​

        protected async Task DeleteAsync(string url)

        {

            var response = await Send(HttpMethod.Delete, url);

        }

​

        private async Task<HttpResponseMessage> Send(HttpMethod httpVerb, string url, object content = null)

        {

            var message = new HttpRequestMessage(httpVerb, url);

​

            if (content != null)

                message.Content = JsonContent.Create(content);

​

            var httpClient = _httpClientFactory.CreateClient();

            var response = await httpClient.SendAsync(message);

            return response;

        }

​

        protected string BuildUrl(string path, Dictionary<string, string> routeParameters = null, Dictionary<string, string> queryParameters = null)

        {

            path = AddRouteParameters(path, routeParameters);

            var url = AppendPath(path);

            url = AppendQuery(url, queryParameters);

            url = HttpUtility.UrlEncode(url);

            return url;

        }

​

        private string AddRouteParameters(string path, Dictionary<string, string> routeParameters)

        {

            if (routeParameters == null || !routeParameters.Any())

                return path;

​

            // add route parameters

            foreach (var routeParameter in routeParameters)

            {

                var parameterId = FormatParameter(routeParameter.Key);

                path = path.Replace(parameterId, routeParameter.Value);

            }

​

            return path;

        }

​

        private string FormatParameter(string parameter)

        {

            return $"{{{parameter.TrimStart('{').TrimEnd('}')}}}";

        }

​

        private string AppendPath(string path)

        {

            return $"{baseURL}/{path}";

        }

​

        private string AppendQuery(string url, Dictionary<string, string> queryParameters)

        {

            if (queryParameters == null || !queryParameters.Any())

                return null;

​

            var parameters = new NameValueCollection();

            queryParameters.ToList().ForEach(p => parameters.Add(p.Key, p.Value));

            return $"{url}?{string.Join('&', parameters.AllKeys.Select(x => $"{x}={parameters[x]}"))}";

        }

}