Neighbourhood.omg.lol/Classes/ApiService.cs

using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;
using Neighbourhood.omg.lol.Models;
using System;
using System.Diagnostics;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Threading;

namespace Neighbourhood.omg.lol
{
  public class ApiService {
    HttpClient _client;
    JsonSerializerOptions _serializerOptions;
    public const string BaseUrl = "https://api.omg.lol";

    public ApiService(string? token = null) {
      _client = new HttpClient();
      _client.BaseAddress = new Uri(BaseUrl);
      _client.DefaultRequestHeaders.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue(App.Name, App.Version));
      _serializerOptions = new JsonSerializerOptions {
        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
#if DEBUG
        WriteIndented = true
#else
        WriteIndented = false
#endif
      };
      AddToken(token);
    }

    /// <summary>
    /// Deserialize json convenience function with default serializer options
    /// </summary>
    /// <typeparam name="T">The type to deserialize</typeparam>
    /// <param name="str">The string to deserialize</param>
    /// <returns>The deserialized object if successful, otherwise default</returns>
    public T? Deserialize<T>(string str) {
      T? responseObj = default;
      try {
        responseObj = JsonSerializer.Deserialize<T>(str, _serializerOptions);
      }
      catch (JsonException ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
        Debug.WriteLine(str);
      }
      return responseObj;
    }

    #region Base Requests

    /// <summary>
    /// Decode the response from an API call
    /// </summary>
    /// <typeparam name="TResponse">The type of response object we are trying to get</typeparam>
    /// <param name="response">The raw Http Response Message</param>
    /// <param name="cancellationToken">A cancellation token to cancel the operation</param>
    /// <returns>The decoded object if successfull, otherwise default</returns>
    private async Task<TResponse?> DecodeResponse<TResponse>(HttpResponseMessage response, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData
    {
      TResponse? responseData = default;
      try {
        string str = await response.Content.ReadAsStringAsync();
        if (response.IsSuccessStatusCode) {
          OmgLolResponse<TResponse>? responseObj = Deserialize<OmgLolResponse<TResponse>>(str);
          if (responseObj?.Request == null || (responseObj?.Request?.Success ?? false)) {
            responseData = responseObj!.Response;
          }
        }
        else {
          OmgLolResponse<TResponse>? responseObj = Deserialize<OmgLolResponse<TResponse>>(str);
          throw responseObj == null ? new OmgLolApiException<TResponse>(str) : new OmgLolApiException<TResponse>(responseObj);
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    /// <summary>
    /// Performs a request for the supplied uri, with the supplied Http Method,
    /// with the supplied data in the body (if present)
    /// </summary>
    /// <typeparam name="TResponse">The type of response we are expecting</typeparam>
    /// <typeparam name="TData">The type of data we are sending</typeparam>
    /// <param name="uri">The uri to request</param>
    /// <param name="method">The Http Method to use for the request</param>
    /// <param name="data">The data to send in the body of the request</param>
    /// <param name="file">A FileResult for the file to send in the body of the request as binary data</param>
    /// <param name="cancellationToken">A cancellation token</param>
    /// <returns>The returned data if successful, otherwise default</returns>
    private async Task<TResponse?> Request<TResponse, TData>(string uri, HttpMethod method, TData? data = default, FileResult? file = null, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData
    {
      TResponse? responseData = default;
      try {
        HttpRequestMessage request = new HttpRequestMessage(method, uri);
        Stream? fileStream = null;
        if (file != null) {
          // append "binary" query parameter (if not already present)
          Uri url = new Uri(_client.BaseAddress?.AbsoluteUri + uri);
          if (string.IsNullOrEmpty(url.Query)) uri += "?binary";
          else if (!url.Query.Contains("binary")) uri += "&binary";
          request = new HttpRequestMessage(method, uri);

          fileStream = await file.OpenReadAsync();
          HttpContent fileStreamContent = new StreamContent(fileStream);
          fileStreamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(file.ContentType ?? "application/octet-stream");
          fileStreamContent.Headers.ContentLength = fileStream.Length;
          request.Content = fileStreamContent;
        }
        else if (data != null) {
          string json = JsonSerializer.Serialize(data, _serializerOptions);
          request.Content = new StringContent(json, Encoding.UTF8, "application/json");
        }
        HttpResponseMessage response = await _client.SendAsync(request, cancellationToken: cancellationToken);
        responseData = await DecodeResponse<TResponse>(response, cancellationToken);

        fileStream?.Dispose();
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    // GET request
    private async Task<TResponse?> Get<TResponse>(string uri, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData
      => await Request<TResponse, object>(uri, HttpMethod.Get, cancellationToken: cancellationToken);

    // POST request
    private async Task<TResponse?> Post<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData 
      => await Request<TResponse, TData>(uri, HttpMethod.Post, data: data, cancellationToken: cancellationToken);

    // POST request, but with a file as binary data
    private async Task<TResponse?> PostBinary<TResponse>(string uri, FileResult? fileResult = null, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData 
      => await Request<TResponse, object>(uri, HttpMethod.Post, file: fileResult, cancellationToken: cancellationToken);

    // PUT request
    private async Task<TResponse?> Put<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData
      => await Request<TResponse, TData>(uri, HttpMethod.Put, data: data, cancellationToken: cancellationToken);

    // PATCH request
    private async Task<TResponse?> Patch<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData
      => await Request<TResponse, TData>(uri, HttpMethod.Patch, data: data, cancellationToken: cancellationToken);

    // Delete request
    private async Task<TResponse?> Delete<TResponse>(string uri, CancellationToken cancellationToken = default)
      where TResponse : IOmgLolResponseData 
      => await Request<TResponse, object>(uri, HttpMethod.Delete, cancellationToken: cancellationToken);
    #endregion

    #region Specific Requests
    public async Task<List<Status>> StatuslogLatest() =>
      (await Get<StatusResponseData>("/statuslog/latest"))?.Statuses ?? new List<Status>();

    public async Task<List<Status>> Statuslog(string address) =>
      (await Get<StatusResponseData>($"/address/{address}/statuses"))?.Statuses ?? new List<Status>();

    public async Task<MarkupString> StatuslogBio(string address) {
      StatusBioResponseData? responseData = await Get<StatusBioResponseData>($"/address/{address}/statuses/bio");
      return Utilities.MdToHtmlMarkup(responseData?.Bio ?? "");
    }

    public async Task<AccountResponseData?> AccountInfo() =>
      await Get<AccountResponseData>("/account/application/info");

    public async Task<AddressResponseList?> Addresses() =>
      await Get<AddressResponseList>("/account/application/addresses");

    public async Task<StatusPostResponseData?> StatusPost(string address, StatusPost statusPost) =>
      await Post<StatusPostResponseData, StatusPost>($"/address/{address}/statuses", statusPost);

    public async Task<List<Pic>> SomePics() =>
      (await Get<SomePicsResponseData>("/pics"))?.Pics ?? new List<Pic>();

    public async Task<List<Pic>> SomePics(string address) =>
      (await Get<SomePicsResponseData>($"/address/{address}/pics"))?.Pics ?? new List<Pic>();

    public async Task<PutPicResponseData?> PutPic(string address, string base64Image) =>
      (await Put<PutPicResponseData, PutPic>($"/address/{address}/pics/upload", new PutPic { Pic = base64Image }));

    public async Task<PutPicResponseData?> PutPic(string address, byte[] bytes) =>
      await PutPic(address, Convert.ToBase64String(bytes));

    public async Task<PutPicResponseData?> PostPicDescription(string address, string id, string? description) =>
      (await Post<PutPicResponseData, PostPic>($"/address/{address}/pics/{id}", new PostPic { Description = description }));
    public async Task<BasicResponseData?> DeletePic(string address, string id) =>
      (await Delete<BasicResponseData>($"/address/{address}/pics/{id}"));

    public async Task<PatchStatusResponseData?> PatchStatus(string address, string id, string content, string? emoji) =>
      (await Patch<PatchStatusResponseData, PatchStatus>($"/address/{address}/statuses/", new PatchStatus { Id = id, Content = content, Emoji = emoji }));

    public async Task<BasicResponseData?> DeleteStatus(string address, string id) =>
      (await Delete<BasicResponseData>($"/address/{address}/statuses/{id}"));

    public async Task<List<NowData>?> NowGarden() =>
      (await Get<NowResponseData>($"/now/garden"))?.Garden ?? new List<NowData>();

    public async Task<List<string>?> Directory() =>
      (await Get<DirectoryResponseData>($"/directory"))?.Directory ?? new List<string>();

    public async Task<NowContentData?> GetNowPage(string address) =>
      (await Get<NowPageResponseData>($"/address/{address}/now"))?.Now;

    public async Task<BasicResponseData?> PostNowPage(string address, string content, bool listed) =>
      await Post<BasicResponseData, NowContentData>($"/address/{address}/now", new NowContentData { Content = content, Listed = listed ? 1 : 0 });

    public async Task<List<MarkupString>> Ephemeral() =>
      (await Get<EphemeralResponseData>($"/ephemeral"))?.Content?.Select(s => (MarkupString)s)?.ToList() ?? new List<MarkupString>();

    public async Task<BasicResponseData?> PostEphemeral(string content) =>
      await Post<BasicResponseData, EphemeralData>("/ephemeral", new EphemeralData { Content = content });

    public async Task<ProfileResponseData?> GetProfile(string address) =>
      await Get<ProfileResponseData>($"/address/{address}/web");

    public async Task<BasicResponseData?> PostProfile(string address, string content, bool publish = true) =>
      await Post<BasicResponseData, PostProfile>($"/address/{address}/web", new PostProfile { Content = content, Publish = publish });

    public async Task<BasicResponseData?> PostProfile(string address, PostProfile data) =>
      await Post<BasicResponseData, PostProfile>($"/address/{address}/web", data);
    public async Task<Dictionary<string, Theme>?> GetThemes() =>
      (await Get<ThemeResponseData>($"/theme/list"))?.Themes;

    public async Task<MarkupString?> GetThemePreview(string theme) =>
      (MarkupString)((await Get<ThemePreviewResponseData>($"/theme/{theme}/preview"))?.Html ?? string.Empty);

    public async Task<BasicResponseData?> PostProfilePic(string address, FileResult image) =>
        await PostBinary<BasicResponseData>($"/address/{address}/pfp", fileResult: image);

    #endregion

    #region Auth
    /// <summary>
    /// Add the api token into the default headers
    /// </summary>
    /// <param name="token">The api token</param>
    public void AddToken(string? token = null) {
      if (token == null) token = Task.Run(() => SecureStorage.GetAsync("accounttoken")).GetAwaiter().GetResult();
      if (token != null) _client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
    }

    /// <summary>
    /// Remove the api token from the default headers
    /// </summary>
    public void RemoveToken() {
      _client.DefaultRequestHeaders.Remove("Authorization");
    }

    public async Task<string?> OAuth(string code, string client_id, string client_secret, string redirect_uri) {
      string? token = null;
      string uri = $"/oauth/?code={code}&client_id={client_id}&client_secret={client_secret}&redirect_uri={redirect_uri}&scope=everything";
      try {
        HttpResponseMessage response = await _client.GetAsync(uri);
        if (response.IsSuccessStatusCode) {
          TokenResponseData? responseObj = await response.Content.ReadFromJsonAsync<TokenResponseData>(_serializerOptions);
          if (responseObj != null && !string.IsNullOrEmpty(responseObj.AccessToken)) {
            token = responseObj.AccessToken;
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }
      return token;
    }
    #endregion

    public async Task<MarkupString?> GetHtml(string url) {
      string? raw = null;
      try {
        HttpResponseMessage response = await _client.GetAsync(url);
        if (response.IsSuccessStatusCode) {
          raw = await response.Content.ReadAsStringAsync();
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }
      return string.IsNullOrEmpty(raw) ? null : (MarkupString)raw;
    }
  }
}