Settings, Administration and conversations; threads that fill in

Settings, which held only the theme, now belong to the persona too:
- its profile (update_credentials, a new PATCH in IHttpService): pictures,
  name, biography and fields as written, locked, bot, discoverable,
  indexable, and how its posts start (visibility, language, sensitive
  media, who may quote them); the composer starts at that visibility;
- the root's personas, each used in turn, and a new one made;
- the accounts it muted or blocked and the servers it blocked, each undone
  there, a server blocked from a pasted address or handle;
- its follows, lists, blocks, mutes, blocked servers and bookmarks exported
  and imported as the CSV files Mastodon writes (PortabilityService): an
  import resolves each row through PrivaPub, one at a time, and can stop.

Administration opens to moderators: reports, resolved there; and for
administrators the servers blocked for everyone and the federation
statistics (traffic by server, delivery success and latency, the crawler).

The Direct tab pages conversations, badges the unread ones, and a card
marks one read or takes it off the list; opening one reads it.

A remote thread is read again 4 and 15 seconds after it opens, since
PrivaPub then fetches the replies its servers hold. A thread its
community locked shows a lock instead of a reply button, reactions stay
visible below a content warning, and a searched handle opens its
account's profile whatever else matched.

The e2e tests cover each: the profile saved and read back, a persona made,
servers blocked and imported, follows exported, an instance block and the
statistics as the pasture's admin, a conversation read and removed, and a
reply only Mastodon held appearing in its thread.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LsXgEaXee4GCU1hwYgPJXw

Services/AccountService.cs

@@ -75,6 +75,35 @@ namespace decePubClient.Services
 			return null;
 		}
 
+		/// <summary>The relationships of many accounts at once, 40 a request.</summary>
+		public async Task<List<Relationship>> Relationships(IReadOnlyList<string> accountIds, CancellationToken cancellationToken = default)
+		{
+			var relationships = new List<Relationship>();
+			foreach (var batch in accountIds.Chunk(40))
+			{
+				using var response = await httpService.Get(APIs.Mastodon.GET_Relationships, [.. batch.Select(id => $"id[]={Uri.EscapeDataString(id)}")],
+					cancellationToken: cancellationToken);
+				if (!response.IsSuccessStatusCode)
+				{
+					await LogFailure(response, nameof(Relationships), cancellationToken);
+					return relationships;
+				}
+				relationships.AddRange(await response.MastodonReadFromJsonAsync<List<Relationship>>(cancellationToken) ?? []);
+			}
+			return relationships;
+		}
+
+		/// <summary>Follows the account, its boosts shown in the home feed or not; Data is the new Relationship.</summary>
+		public async Task<WebResult> Follow(string accountId, bool showReblogs, CancellationToken cancellationToken = default)
+		{
+			using var response = await httpService.Post(APIs.Mastodon.POST_M_AccountAction(accountId, "follow"),
+				new[] { new KeyValuePair<string, string>("reblogs", showReblogs ? "true" : "false") }, cancellationToken: cancellationToken);
+			if (!response.IsSuccessStatusCode)
+				return await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);
+
+			return new WebResult { Data = await response.MastodonReadFromJsonAsync<Relationship>(cancellationToken) };
+		}
+
 		/// <summary>Follows, unfollows, blocks, unblocks, mutes or unmutes; Data is the new Relationship.</summary>
 		public async Task<WebResult> Act(string accountId, AccountAction action, CancellationToken cancellationToken = default)
 		{
@@ -152,6 +181,71 @@ namespace decePubClient.Services
 			return new SearchResults();
 		}
 
+		/// <summary>Saves the persona's profile; Data is its account as PrivaPub now describes it (with its Source).</summary>
+		public async Task<WebResult> UpdateProfile(ProfileForm form, CancellationToken cancellationToken = default)
+		{
+			using var response = await httpService.Patch(APIs.Mastodon.PATCH_UpdateCredentials, (Func<HttpContent>)form.Content,
+				cancellationToken: cancellationToken);
+			if (!response.IsSuccessStatusCode)
+				return await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);
+
+			var account = await response.MastodonReadFromJsonAsync<Account>(cancellationToken);
+			return account?.Id is null
+				? new WebResult().Invalidate(localizer["The server sent an invalid response."], (int)HttpStatusCode.BadGateway)
+				: new WebResult { Data = account };
+		}
+
+		/// <summary>A page of the accounts the persona follows (only the persona itself may read it); Data is an AccountPage.</summary>
+		public Task<WebResult> Following(string accountId, string maxId, CancellationToken cancellationToken = default) =>
+			Accounts(APIs.Mastodon.GET_M_AccountFollowing(accountId), maxId, cancellationToken);
+
+		/// <summary>A page of the accounts the persona muted; Data is an AccountPage.</summary>
+		public Task<WebResult> Mutes(string maxId, CancellationToken cancellationToken = default) =>
+			Accounts(APIs.Mastodon.GET_Mutes, maxId, cancellationToken);
+
+		/// <summary>A page of the accounts the persona blocked; Data is an AccountPage.</summary>
+		public Task<WebResult> Blocks(string maxId, CancellationToken cancellationToken = default) =>
+			Accounts(APIs.Mastodon.GET_Blocks, maxId, cancellationToken);
+
+		async Task<WebResult> Accounts(string route, string maxId, CancellationToken cancellationToken)
+		{
+			var parameters = new List<string> { "limit=40" };
+			if (maxId is not null)
+				parameters.Add($"max_id={Uri.EscapeDataString(maxId)}");
+			using var response = await httpService.Get(route, [.. parameters], cancellationToken: cancellationToken);
+			if (!response.IsSuccessStatusCode)
+				return await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);
+
+			var accounts = await response.MastodonReadFromJsonAsync<List<Account>>(cancellationToken) ?? [];
+			var (nextMaxId, _) = response.PageCursors();
+			return new WebResult { Data = new AccountPage { Accounts = accounts, MaxId = accounts.Count == 0 ? null : nextMaxId } };
+		}
+
+		/// <summary>The servers the persona blocked: nothing from them reaches it, and its followers there are removed.</summary>
+		public async Task<List<string>> DomainBlocks(CancellationToken cancellationToken = default)
+		{
+			using var response = await httpService.Get(APIs.Mastodon.GET_DomainBlocks, ["limit=200"], cancellationToken: cancellationToken);
+			if (response.IsSuccessStatusCode)
+				return await response.MastodonReadFromJsonAsync<List<string>>(cancellationToken) ?? [];
+
+			await LogFailure(response, nameof(DomainBlocks), cancellationToken);
+			return [];
+		}
+
+		public async Task<WebResult> BlockDomain(string domain, CancellationToken cancellationToken = default)
+		{
+			using var response = await httpService.Post(APIs.Mastodon.POST_DomainBlocks, new[] { new KeyValuePair<string, string>("domain", domain.Trim()) },
+				cancellationToken: cancellationToken);
+			return response.IsSuccessStatusCode ? new WebResult() : await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);
+		}
+
+		public async Task<WebResult> UnblockDomain(string domain, CancellationToken cancellationToken = default)
+		{
+			using var response = await httpService.Delete(APIs.Mastodon.DELETE_DomainBlocks, [$"domain={Uri.EscapeDataString(domain)}"],
+				cancellationToken: cancellationToken);
+			return response.IsSuccessStatusCode ? new WebResult() : await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);
+		}
+
 		async Task LogFailure(HttpResponseMessage response, string caller, CancellationToken cancellationToken)
 		{
 			var result = await response.Content.ReadWebResult(response.StatusCode, localizer, cancellationToken);