297 lines
11 KiB
C#
297 lines
11 KiB
C#
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Text;
|
|
|
|
namespace Uwaa.Pleroma;
|
|
|
|
delegate void AddPair(string key, string value);
|
|
|
|
/// <summary>
|
|
/// A pleroma client.
|
|
/// </summary>
|
|
public class Pleroma
|
|
{
|
|
static readonly JsonSerializerOptions SerializerOptions = new()
|
|
{
|
|
PropertyNameCaseInsensitive = true,
|
|
NumberHandling = JsonNumberHandling.AllowReadingFromString,
|
|
};
|
|
|
|
static string CreateQuery(Action<AddPair> generator)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
void addPair(string key, string value)
|
|
{
|
|
if (sb.Length == 0)
|
|
sb.Append('?');
|
|
else
|
|
sb.Append('&');
|
|
sb.Append(WebUtility.UrlEncode(key));
|
|
sb.Append('=');
|
|
sb.Append(WebUtility.UrlEncode(value));
|
|
}
|
|
generator(addPair);
|
|
return sb.ToString();
|
|
}
|
|
|
|
|
|
public HttpClient HttpClient;
|
|
|
|
public Pleroma(string host, string? authorization, string? userAgent = "Uwaa.Pleroma/0.0")
|
|
{
|
|
UriBuilder builder = new UriBuilder();
|
|
builder.Scheme = "https";
|
|
builder.Host = host;
|
|
|
|
HttpClient = new HttpClient();
|
|
HttpClient.DefaultRequestHeaders.Add("User-agent", userAgent);
|
|
HttpClient.BaseAddress = builder.Uri;
|
|
HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
|
if (authorization != null)
|
|
HttpClient.DefaultRequestHeaders.Authorization = AuthenticationHeaderValue.Parse(authorization);
|
|
}
|
|
|
|
async Task<T?> Retry<T>(HttpRequestMessage req)
|
|
{
|
|
while (true)
|
|
{
|
|
HttpResponseMessage res = await HttpClient.SendAsync(req);
|
|
|
|
if (res.StatusCode == HttpStatusCode.NotFound)
|
|
return default;
|
|
|
|
if (res.Content == null)
|
|
throw new HttpRequestException("Server responded with no content");
|
|
|
|
string text = await res.Content.ReadAsStringAsync();
|
|
|
|
if (res.StatusCode is >= (HttpStatusCode)400 and < (HttpStatusCode)600)
|
|
{
|
|
try
|
|
{
|
|
PleromaException? err = JsonSerializer.Deserialize<PleromaException>(text, SerializerOptions);
|
|
if (err != null && err.Text != null)
|
|
{
|
|
if (err.Text == "Throttled")
|
|
{
|
|
await Task.Delay(5000);
|
|
continue; //Retry
|
|
}
|
|
else
|
|
{
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
//Not an error
|
|
}
|
|
}
|
|
|
|
if (res.StatusCode is >= (HttpStatusCode)200 and < (HttpStatusCode)300)
|
|
return JsonSerializer.Deserialize<T>(text, SerializerOptions) ?? throw new HttpRequestException("Couldn't deserialize response");
|
|
else
|
|
throw new HttpRequestException("Unknown error occurred");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Posts a status.
|
|
/// </summary>
|
|
/// <param name="content">Text content of the status.</param>
|
|
/// <param name="sensitive">Mark status and attached media as sensitive?</param>
|
|
/// <param name="expiresIn">The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.</param>
|
|
/// <param name="replyTo">ID of the status being replied to, if status is a reply</param>
|
|
/// <param name="quoting"> ID of the status being quoted.</param>
|
|
/// <param name="language">ISO 639 language code for this status.</param>
|
|
/// <param name="visibility">Visibility of the posted status.</param>
|
|
/// <exception cref="HttpRequestException">Thrown if something goes wrong while uploading the status.</exception>
|
|
/// <returns>The status if posting was successful.</returns>
|
|
public Task<Status> PostStatus(string content,
|
|
bool sensitive = false,
|
|
int? expiresIn = null,
|
|
string? replyTo = null,
|
|
string? quoting = null,
|
|
string? language = null,
|
|
StatusVisibility visibility = StatusVisibility.Public)
|
|
{
|
|
MemoryStream mem = new MemoryStream();
|
|
|
|
{
|
|
Utf8JsonWriter writer = new Utf8JsonWriter(mem, new JsonWriterOptions() { SkipValidation = true });
|
|
writer.WriteStartObject();
|
|
|
|
writer.WritePropertyName("status");
|
|
writer.WriteStringValue(content);
|
|
|
|
writer.WritePropertyName("content-type");
|
|
writer.WriteStringValue("text/plain");
|
|
|
|
if (sensitive)
|
|
{
|
|
writer.WritePropertyName("sensitive");
|
|
writer.WriteBooleanValue(true);
|
|
}
|
|
|
|
if (expiresIn.HasValue)
|
|
{
|
|
writer.WritePropertyName("expires_in");
|
|
writer.WriteNumberValue(expiresIn.Value);
|
|
}
|
|
|
|
if (replyTo != null)
|
|
{
|
|
writer.WritePropertyName("in_reply_to_id");
|
|
writer.WriteStringValue(replyTo);
|
|
}
|
|
|
|
if (quoting != null)
|
|
{
|
|
writer.WritePropertyName("quote_id");
|
|
writer.WriteStringValue(quoting);
|
|
}
|
|
|
|
if (language != null)
|
|
{
|
|
writer.WritePropertyName("language");
|
|
writer.WriteStringValue(language);
|
|
}
|
|
|
|
if (visibility != StatusVisibility.Public)
|
|
{
|
|
writer.WritePropertyName("visibility");
|
|
writer.WriteStringValue(visibility.ToString().ToLowerInvariant());
|
|
}
|
|
|
|
writer.WriteEndObject();
|
|
writer.Flush();
|
|
}
|
|
|
|
mem.Position = 0;
|
|
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, "/api/v1/statuses");
|
|
req.Content = new StreamContent(mem);
|
|
req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
|
|
|
|
return Retry<Status>(req)!;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the latest statuses from the public timeline.
|
|
/// </summary>
|
|
public Task<Status[]> GetTimeline()
|
|
{
|
|
//TODO: Parameters and selecting different timelines (home, public, bubble)
|
|
|
|
return Retry<Status[]>(new HttpRequestMessage(HttpMethod.Get, "/api/v1/timelines/public"))!;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Fetches the latest statuses from a user's timeline.
|
|
/// </summary>
|
|
public Task<Status[]> GetTimeline(Account account)
|
|
=> GetTimeline(account.ID);
|
|
|
|
/// <summary>
|
|
/// Fetches the latest statuses from a user's timeline.
|
|
/// </summary>
|
|
public Task<Status[]> GetTimeline(string account_id)
|
|
{
|
|
return Retry<Status[]>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/{account_id}/statuses"))!;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the account of the pleroma client.
|
|
/// </summary>
|
|
public Task<Account> GetAccount()
|
|
{
|
|
return Retry<Account>(new HttpRequestMessage(HttpMethod.Get, "/api/v1/accounts/verify_credentials"))!;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches an account.
|
|
/// </summary>
|
|
public Task<Account?> GetAccount(string id)
|
|
{
|
|
return Retry<Account?>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/{id}"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the context of a status.
|
|
/// </summary>
|
|
public Task<Context?> GetContext(Status status)
|
|
=> GetContext(status.ID);
|
|
|
|
/// <summary>
|
|
/// Fetches the context of a status.
|
|
/// </summary>
|
|
public Task<Context?> GetContext(string status_id)
|
|
{
|
|
return Retry<Context?>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/statuses/{status_id}/context"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches a status.
|
|
/// </summary>
|
|
public Task<Status?> GetStatus(string status_id)
|
|
{
|
|
return Retry<Status?>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/statuses/{status_id}"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes a status.
|
|
/// </summary>
|
|
public Task Delete(Status status)
|
|
=> Delete(status.ID);
|
|
|
|
/// <summary>
|
|
/// Deletes a status by ID.
|
|
/// </summary>
|
|
public Task Delete(string status_id)
|
|
{
|
|
//TODO: Test
|
|
return Retry<object?>(new HttpRequestMessage(HttpMethod.Delete, $"/api/v1/statuses/{status_id}"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for an accounts, hashtags, and/or statuses.
|
|
/// </summary>
|
|
/// <param name="query">What to search for</param>
|
|
/// <param name="account_id">If provided, statuses returned will be authored only by this account</param>
|
|
/// <param name="type">Search type</param>
|
|
/// <param name="resolve">Attempt WebFinger lookup</param>
|
|
/// <param name="following">Only include accounts that the user is following</param>
|
|
/// <param name="max_id">Return items older than this ID</param>
|
|
/// <param name="min_id">Return the oldest items newer than this ID</param>
|
|
/// <param name="since_id">Return the newest items newer than this ID</param>
|
|
/// <param name="offset">Return items past this number of items</param>
|
|
/// <param name="limit">Maximum number of items to return. Will be ignored if it's more than 40</param>
|
|
/// <returns></returns>
|
|
public Task<SearchResults> Search(string query,
|
|
string? account_id = null,
|
|
SearchType type = SearchType.All,
|
|
bool resolve = false,
|
|
bool following = false,
|
|
string? max_id = null,
|
|
string? min_id = null,
|
|
string? since_id = null,
|
|
int offset = 0,
|
|
int limit = 20)
|
|
{
|
|
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Get, "/api/v2/search" + CreateQuery(addPair =>
|
|
{
|
|
addPair("q", query);
|
|
if (account_id != null) addPair("account_id", account_id);
|
|
if (type != SearchType.All) addPair("type", type.ToString().ToLowerInvariant());
|
|
if (resolve) addPair("resolve", "true");
|
|
if (following) addPair("following", "true");
|
|
if (max_id != null) addPair("max_id", max_id);
|
|
if (min_id != null) addPair("min_id", min_id);
|
|
if (since_id != null) addPair("since_id", since_id);
|
|
if (offset > 0) addPair("offset", offset.ToString());
|
|
if (limit != 20) addPair("limit", limit.ToString());
|
|
}));
|
|
return Retry<SearchResults>(req)!;
|
|
}
|
|
}
|