455 lines
19 KiB
C#
455 lines
19 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>
|
|
/// Fetches the account of the pleroma client.
|
|
/// </summary>
|
|
public Task<Account> GetAccount() => Retry<Account>(new HttpRequestMessage(HttpMethod.Get, "/api/v1/accounts/verify_credentials"))!;
|
|
|
|
/// <summary>
|
|
/// Fetches an account by ID.
|
|
/// </summary>
|
|
/// <param name="id">Account ID to fetch</param>
|
|
public Task<Account?> GetAccountByID(string id) => Retry<Account>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/{WebUtility.UrlEncode(id)}"));
|
|
|
|
/// <summary>
|
|
/// Fetches an account by nickname.
|
|
/// </summary>
|
|
/// <param name="acct">User nickname</param>
|
|
public Task<Account?> GetAccountByName(string acct) => Retry<Account>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/lookup?acct={WebUtility.UrlEncode(acct)}"));
|
|
|
|
/// <summary>
|
|
/// Follows the given account.
|
|
/// </summary>
|
|
/// <param name="id">Account to follow</param>
|
|
/// <returns>The new relationship, if the provided account exists.</returns>
|
|
public Task<Relationship?> Follow(AccountID account) => Retry<Relationship>(new HttpRequestMessage(HttpMethod.Post, $"/api/v1/accounts/{WebUtility.UrlEncode(account.ID)}/follow"));
|
|
|
|
/// <summary>
|
|
/// Unfollows the given account.
|
|
/// </summary>
|
|
/// <param name="id">Account to unfollow</param>
|
|
/// <returns>The new state of the relationship, if the provided account exists.</returns>
|
|
public Task<Relationship?> Unfollow(AccountID account) => Retry<Relationship>(new HttpRequestMessage(HttpMethod.Post, $"/api/v1/accounts/{WebUtility.UrlEncode(account.ID)}/unfollow"));
|
|
|
|
/// <summary>
|
|
/// Sets a private note for the given account.
|
|
/// </summary>
|
|
/// <param name="id">Account ID</param>
|
|
/// <param name="comment">Account note body</param>
|
|
/// <returns></returns>
|
|
public Task<Relationship?> SetUserNote(AccountID account, string comment)
|
|
{
|
|
MemoryStream mem = new MemoryStream();
|
|
|
|
{
|
|
Utf8JsonWriter writer = new Utf8JsonWriter(mem, new JsonWriterOptions() { SkipValidation = true });
|
|
writer.WriteStartObject();
|
|
|
|
writer.WritePropertyName("comment");
|
|
writer.WriteStringValue(comment);
|
|
|
|
writer.WriteEndObject();
|
|
writer.Flush();
|
|
}
|
|
|
|
mem.Position = 0;
|
|
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/accounts/{WebUtility.UrlEncode(account.ID)}/note");
|
|
req.Content = new StreamContent(mem);
|
|
req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
|
|
|
|
return Retry<Relationship>(req)!;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the account's relationship with the given account.
|
|
/// </summary>
|
|
/// <param name="id">Account ID</param>
|
|
/// <returns>A relationship object for the requested account, if the account exists.</returns>
|
|
public async Task<Relationship?> GetRelationship(AccountID account)
|
|
{
|
|
Relationship[]? rels = await Retry<Relationship[]>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/relationships?id={WebUtility.UrlEncode(account.ID)}"));
|
|
if (rels == null || rels.Length == 0)
|
|
return null;
|
|
else
|
|
return rels[0];
|
|
}
|
|
|
|
/// <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>
|
|
/// Reposts/boosts/shares a status.
|
|
/// </summary>
|
|
/// <param name="status">The status to reblog.</param>
|
|
/// <returns>The reblogged status, if it exists.</returns>
|
|
public Task<Status?> Reblog(StatusID status, StatusVisibility? visibility = null)
|
|
{
|
|
MemoryStream mem = new MemoryStream();
|
|
|
|
{
|
|
Utf8JsonWriter writer = new Utf8JsonWriter(mem, new JsonWriterOptions() { SkipValidation = true });
|
|
writer.WriteStartObject();
|
|
|
|
if (visibility.HasValue)
|
|
{
|
|
writer.WritePropertyName("visibility");
|
|
writer.WriteStringValue(visibility.Value.ToString().ToLowerInvariant());
|
|
}
|
|
|
|
writer.WriteEndObject();
|
|
writer.Flush();
|
|
}
|
|
|
|
mem.Position = 0;
|
|
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/statuses/{WebUtility.UrlEncode(status.ID)}/reblog");
|
|
req.Content = new StreamContent(mem);
|
|
req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
|
|
|
|
return Retry<Status>(req);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes a reblog.
|
|
/// </summary>
|
|
/// <param name="status">The reblogged status to undo.</param>
|
|
/// <returns>The status, if it exists.</returns>
|
|
public Task<Status?> Unreblog(StatusID status) => Retry<Status>(new HttpRequestMessage(HttpMethod.Post, $"/api/v1/statuses/{WebUtility.UrlEncode(status.ID)}/unreblog"))!;
|
|
|
|
|
|
/// <summary>
|
|
/// Likes/favourites a status, adding it to the account's favourite list.
|
|
/// </summary>
|
|
/// <param name="status">The status to favourite.</param>
|
|
/// <returns>The favourited status, if it exists.</returns>
|
|
public Task<Status?> Favourite(StatusID status) => Retry<Status>(new HttpRequestMessage(HttpMethod.Post, $"/api/v1/statuses/{WebUtility.UrlEncode(status.ID)}/favourite"))!;
|
|
|
|
/// <summary>
|
|
/// Unfavourites a favorited status, removing it from the account's favourite list.
|
|
/// </summary>
|
|
/// <param name="status">The status to unfavourite.</param>
|
|
/// <returns>The status, if it exists.</returns>
|
|
public Task<Status?> Unfavourite(StatusID status) => Retry<Status>(new HttpRequestMessage(HttpMethod.Post, $"/api/v1/statuses/{WebUtility.UrlEncode(status.ID)}/unfavourite"))!;
|
|
|
|
/// <summary>
|
|
/// Fetches the latest statuses from a standard timeline.
|
|
/// </summary>
|
|
public Task<Status[]> GetTimeline(Timeline timeline,
|
|
bool local = false,
|
|
string? instance = null,
|
|
bool only_media = false,
|
|
bool remote = false,
|
|
bool with_muted = false,
|
|
StatusVisibility[]? exclude_visibilities = null,
|
|
ReplyVisibility? reply_visibility = null,
|
|
string? max_id = null,
|
|
string? min_id = null,
|
|
string? since_id = null,
|
|
int offset = 0,
|
|
int limit = 20)
|
|
{
|
|
string timelineName;
|
|
switch (timeline)
|
|
{
|
|
case Timeline.Direct:
|
|
timelineName = "direct";
|
|
break;
|
|
case Timeline.Home:
|
|
timelineName = "home";
|
|
break;
|
|
case Timeline.Local:
|
|
timelineName = "public";
|
|
local = true;
|
|
break;
|
|
case Timeline.Bubble:
|
|
timelineName = "bubble";
|
|
break;
|
|
case Timeline.Public:
|
|
timelineName = "public";
|
|
break;
|
|
|
|
default:
|
|
throw new ArgumentException("Invalid timeline", nameof(timeline));
|
|
}
|
|
|
|
return Retry<Status[]>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/timelines/{timelineName}" + CreateQuery(addPair =>
|
|
{
|
|
if (local) addPair("local", "true");
|
|
if (instance != null) addPair("instance", instance);
|
|
if (only_media) addPair("only_media", "true");
|
|
if (remote) addPair("remote", "true");
|
|
if (with_muted) addPair("with_muted", "true");
|
|
if (exclude_visibilities != null) addPair("exclude_visibilities", JsonSerializer.Serialize(exclude_visibilities));
|
|
if (reply_visibility.HasValue) addPair("reply_visibility", reply_visibility.Value.ToString().ToLowerInvariant());
|
|
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());
|
|
})))!;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Fetches the latest statuses from a user's timeline.
|
|
/// </summary>
|
|
public Task<Status[]?> GetTimeline(AccountID account,
|
|
bool pinned = false,
|
|
string? tagged = null,
|
|
bool only_media = false,
|
|
bool with_muted = false,
|
|
bool exclude_reblogs = false,
|
|
bool exclude_replies = false,
|
|
StatusVisibility[]? exclude_visibilities = null,
|
|
string? max_id = null,
|
|
string? min_id = null,
|
|
string? since_id = null,
|
|
int offset = 0,
|
|
int limit = 20)
|
|
{
|
|
|
|
return Retry<Status[]>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/accounts/{WebUtility.UrlEncode(account.ID)}/statuses" + CreateQuery(addPair =>
|
|
{
|
|
if (pinned) addPair("pinned", "true");
|
|
if (tagged != null) addPair("tagged", tagged);
|
|
if (only_media) addPair("only_media", "true");
|
|
if (with_muted) addPair("with_muted", "true");
|
|
if (exclude_reblogs) addPair("exclude_reblogs", "true");
|
|
if (exclude_replies) addPair("exclude_replies", "true");
|
|
if (exclude_visibilities != null) addPair("exclude_visibilities", JsonSerializer.Serialize(exclude_visibilities));
|
|
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());
|
|
})));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the context of a status.
|
|
/// </summary>
|
|
public Task<Context?> GetContext(StatusID status) => Retry<Context>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/statuses/{WebUtility.UrlEncode(status.ID)}/context"));
|
|
|
|
/// <summary>
|
|
/// Fetches a status by ID.
|
|
/// </summary>
|
|
public Task<Status?> GetStatus(string id) => Retry<Status>(new HttpRequestMessage(HttpMethod.Get, $"/api/v1/statuses/{WebUtility.UrlEncode(id)}"));
|
|
|
|
/// <summary>
|
|
/// Deletes a status.
|
|
/// </summary>
|
|
public Task<Status?> Delete(StatusID status) => Retry<Status>(new HttpRequestMessage(HttpMethod.Delete, $"/api/v1/statuses/{WebUtility.UrlEncode(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)!;
|
|
}
|
|
}
|