SimpleMessagingService

Log | Files | Refs | README

ApiInterface.cs (2884B)

      1 using Shared.Contracts;
      2 using System.Diagnostics;
      3 using System.Net.Http;
      4 using System.Text.Json;
      5 
      6 namespace Client.Utilities;
      7 
      8 public interface IApiInterface
      9 {
     10     Task<GetMessagesContract?> GetMessagesAsync();
     11     Task<GetUsersContract?> GetUsersAsync();
     12     Task<HttpResponseMessage?> PostMessageAsync(string message);
     13     Task<HttpResponseMessage> PostUserAsync(string name);
     14     Guid ServerKey { get; set; }
     15 }
     16 
     17 public class ApiInterface : IApiInterface
     18 {
     19     private readonly HttpClient _httpClient;
     20     public Guid ServerKey { get; set; } = Guid.Empty;
     21 
     22     public ApiInterface(Uri baseUrl)
     23     {
     24         _httpClient = new HttpClient();
     25         _httpClient.BaseAddress = baseUrl;
     26     }
     27 
     28     public async Task<GetMessagesContract?> GetMessagesAsync()
     29     { 
     30         return await getContract<GetMessagesContract>(Shared.Endpoints.Messages);
     31     }
     32 
     33     public async Task<GetUsersContract?> GetUsersAsync()
     34     {
     35         return await getContract<GetUsersContract>(Shared.Endpoints.Users);
     36     }
     37 
     38     public async Task<HttpResponseMessage?> PostMessageAsync(string message)
     39     {
     40         var messageContract = new MessageContract { Content = message, Key = ServerKey };
     41         return await postContract(messageContract, Shared.Endpoints.Messages);
     42     }
     43 
     44     public async Task<HttpResponseMessage?> PostUserAsync(string name)
     45     {
     46         var userContract = new UserContract { Username = name };
     47         return await postContract(userContract, Shared.Endpoints.Users);
     48     }
     49 
     50     private async Task<HttpResponseMessage> postContract<T>(T content, string endpoint)
     51     {
     52         try
     53         {
     54             var json = JsonSerializer.Serialize(content);
     55             HttpContent httpContent = new StringContent(json);
     56             httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
     57             var response = await _httpClient.PostAsync(endpoint, httpContent);
     58             Debug.WriteLine(await response.Content.ReadAsStringAsync());
     59             return response;
     60         }
     61         catch (Exception e)
     62         {
     63             Debug.WriteLine(e.Message);
     64             return default;
     65         }
     66     }
     67 
     68     private async Task<T?> getContract<T>(string endpoint)
     69     {
     70         int attempts = 0;
     71         do
     72         {
     73             try
     74             {
     75                 var response = await _httpClient.GetAsync(endpoint);
     76                 var responseContent = await response.Content.ReadAsStringAsync();
     77                 Debug.WriteLine(responseContent);
     78                 return JsonSerializer.Deserialize<T>(responseContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
     79             }
     80             catch (Exception e)
     81             {
     82                 attempts++;
     83                 Debug.WriteLine($"Failed after {attempts} tries.\n{e.Message}");
     84             }
     85         }
     86         while (attempts < 10);
     87 
     88         return default;
     89     }
     90 }