net10, the refactor finished, and federation that works

The tree had not compiled since its first commit: Group, DmGroup and
IGroupUsersService were referenced and never written, an IDE rename had
turned the user-settings DTO into the ViewAvatarServer enum, and the settings
were saved as an entity they no longer were.

Built now:
- Group (an ActivityPub Group actor with its own keys, members, invitation
  code and optional password) and DmGroup (a conversation), with
  /clientapi/group/{list,insert,update,join,leave,approve}.
- Posts and DMs: /clientapi/post/{list,insert,delete}, /clientapi/dm/{list,insert};
  DM recipients are local usernames or user@host handles resolved by WebFinger.
- Invitation sign-up and login against the group's invitation code, checking
  the password before any account is created.
- Federation: WebFinger, NodeInfo 2.0, actors at /peasants/{name} (Person,
  Group, and an Application instance actor) with SPKI keys, draft-cavage
  RSA-SHA256 HTTP signatures both ways, an inbox handling Follow (+Accept),
  Undo, Create, Delete and Update, an outbox, notes at /posts/{id}, and a
  persisted, retried, signed delivery queue. A post to a group is announced
  by the group to its followers (FEP-1b12).
- The unused, broken typed ActivityPub models are replaced by a renderer;
  NSign's HMAC setup, which could not federate, is gone.

Upgrade: net10.0, MongoDB.Entities 25.1 (instance DB API, Standard GUIDs),
Swashbuckle 10 / OpenApi 2, Serilog.AspNetCore 10, MailKit 4.18,
PasswordGenerator 3. The JWT keys are 64 bytes (IdentityModel 8 refuses
shorter for HS512). Production runs its own mongod on 127.0.0.1:27022, as
Sintopia's apps do, and deploys to privapub.thepra.dev from the build runner.

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

PrivaPub/Controllers/ClientToServer/GroupController.cs

@@ -0,0 +1,55 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Localization;
+
+using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Group;
+using PrivaPub.Extensions;
+using PrivaPub.Resources;
+using PrivaPub.Services;
+
+namespace PrivaPub.Controllers.ClientToServer
+{
+	[ApiController,
+		Route("clientapi/group"),
+		Authorize(Policy = Policies.IsUser)]
+	public class GroupController : ControllerBase
+	{
+		readonly IGroupUsersService _groupUsersService;
+		readonly IStringLocalizer _localizer;
+
+		public GroupController(IGroupUsersService groupUsersService, IStringLocalizer<GenericRes> localizer)
+		{
+			_groupUsersService = groupUsersService;
+			_localizer = localizer;
+		}
+
+		[HttpGet, Route("/clientapi/group/list")]
+		public async Task<IActionResult> List([FromQuery] string avatarId, CancellationToken token) =>
+			Answer(await _groupUsersService.GetGroups(User.GetUserId(), avatarId, token));
+
+		[HttpPost, Route("/clientapi/group/insert")]
+		public async Task<IActionResult> Insert(InsertGroupForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _groupUsersService.InsertGroup(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/group/update")]
+		public async Task<IActionResult> Update(UpdateGroupForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _groupUsersService.UpdateGroup(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/group/join")]
+		public async Task<IActionResult> Join(JoinGroupForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _groupUsersService.JoinGroup(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/group/leave")]
+		public async Task<IActionResult> Leave(GroupMembershipForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _groupUsersService.LeaveGroup(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/group/approve")]
+		public async Task<IActionResult> Approve(GroupMembershipForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _groupUsersService.ApproveMember(User.GetUserId(), form, token));
+
+		IActionResult Invalid() => BadRequest(new WebResult().Invalidate(_localizer["Invalid model."]));
+
+		IActionResult Answer(WebResult result) => result.IsValid ? Ok(result.Data) : StatusCode(result.StatusCode, result);
+	}
+}

PrivaPub/Controllers/ClientToServer/PostController.cs

@@ -0,0 +1,51 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Localization;
+
+using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Post;
+using PrivaPub.Extensions;
+using PrivaPub.Resources;
+using PrivaPub.Services;
+
+namespace PrivaPub.Controllers.ClientToServer
+{
+	[ApiController,
+		Route("clientapi/post"),
+		Authorize(Policy = Policies.IsUser)]
+	public class PostController : ControllerBase
+	{
+		readonly IPostsService _postsService;
+		readonly IStringLocalizer _localizer;
+
+		public PostController(IPostsService postsService, IStringLocalizer<GenericRes> localizer)
+		{
+			_postsService = postsService;
+			_localizer = localizer;
+		}
+
+		[HttpGet, Route("/clientapi/post/list")]
+		public async Task<IActionResult> List([FromQuery] string avatarId, [FromQuery] string groupId, CancellationToken token) =>
+			Answer(await _postsService.GetPosts(User.GetUserId(), avatarId, groupId, token));
+
+		[HttpPost, Route("/clientapi/post/insert")]
+		public async Task<IActionResult> Insert(InsertPostForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _postsService.InsertPost(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/post/delete")]
+		public async Task<IActionResult> Delete(DeletePostForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _postsService.DeletePost(User.GetUserId(), form, token));
+
+		[HttpGet, Route("/clientapi/dm/list")]
+		public async Task<IActionResult> Dms([FromQuery] string avatarId, [FromQuery] string dmGroupId, CancellationToken token) =>
+			Answer(await _postsService.GetDms(User.GetUserId(), avatarId, dmGroupId, token));
+
+		[HttpPost, Route("/clientapi/dm/insert")]
+		public async Task<IActionResult> InsertDm(InsertDmForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _postsService.InsertDm(User.GetUserId(), form, token));
+
+		IActionResult Invalid() => BadRequest(new WebResult().Invalidate(_localizer["Invalid model."]));
+
+		IActionResult Answer(WebResult result) => result.IsValid ? Ok(result.Data) : StatusCode(result.StatusCode, result);
+	}
+}

PrivaPub/Controllers/ClientToServer/PrivateAvatarController.cs

@@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Localization;
 using PrivaPub.ClientModels;
@@ -27,6 +27,13 @@ namespace PrivaPub.Controllers.ClientToServer
 			_logger = logger;
 		}
 
+		[HttpGet, Route("/clientapi/avatar/private/list")]
+		public async Task<IActionResult> GetAvatars(CancellationToken token)
+		{
+			var result = await _privateAvatarUsersService.GetRootAvatars(User.GetUserId(), token);
+			return result.IsValid ? Ok(result.Data) : StatusCode(result.StatusCode, result);
+		}
+
 		[HttpPost, Route("/clientapi/avatar/private/insert")]
 		public async Task<IActionResult> InsertAvatar(InsertAvatarForm model)
 		{

PrivaPub/Controllers/ClientToServer/RootUserController.cs

@@ -1,15 +1,20 @@
-using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Options;
 
 using PrivaPub.ClientModels;
 using PrivaPub.ClientModels.Resources;
+using PrivaPub.ClientModels.Group;
 using PrivaPub.ClientModels.User;
+using PrivaPub.ClientModels.User.Avatar;
 using PrivaPub.Extensions;
+using PrivaPub.Models;
 using PrivaPub.Models.User;
 using PrivaPub.Resources;
 using PrivaPub.Services;
+using PrivaPub.Services.ClientToServer.Private;
 using PrivaPub.StaticServices;
 
 using System.ComponentModel.DataAnnotations;
@@ -21,17 +26,26 @@ namespace PrivaPub.Controllers.ClientToServer
 	public class RootUserController : ControllerBase
 	{
 		readonly IRootUsersService UsersService;
+		readonly IGroupUsersService GroupUsersService;
+		readonly IPrivateAvatarUsersService AvatarUsersService;
 		readonly AuthTokenManager AuthTokenManager;
+		readonly IOptionsMonitor<AppConfiguration> AppConfiguration;
 		readonly ILogger<RootUserController> Logger;
 		readonly IStringLocalizer Localizer;
 
 		public RootUserController(IRootUsersService usersService,
+				IGroupUsersService groupUsersService,
+				IPrivateAvatarUsersService avatarUsersService,
 				AuthTokenManager authTokenManager,
+				IOptionsMonitor<AppConfiguration> appConfiguration,
 				IStringLocalizer<GenericRes> localizer,
 				ILogger<RootUserController> logger)
 		{
 			UsersService = usersService;
+			GroupUsersService = groupUsersService;
+			AvatarUsersService = avatarUsersService;
 			AuthTokenManager = authTokenManager;
+			AppConfiguration = appConfiguration;
 			Localizer = localizer;
 			Logger = logger;
 		}
@@ -51,7 +65,7 @@ namespace PrivaPub.Controllers.ClientToServer
 				if (!result.IsValid)
 					return StatusCode(result.StatusCode, result);
 
-				(var user, var userSettings) = ((RootUser, ViewAvatarServer))result.Data;
+				(var user, var userSettings) = ((RootUser, ViewUserSettings))result.Data;
 				var jwtUser = AuthTokenManager.GenerateToken(user, userSettings);
 				Logger.LogInformation(
 						$"{nameof(SignUp)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
@@ -78,7 +92,7 @@ namespace PrivaPub.Controllers.ClientToServer
 					return StatusCode(result.StatusCode, result);
 
 				var (user, userSettings) =
-						((RootUser, ViewAvatarServer))result.Data;
+						((RootUser, ViewUserSettings))result.Data;
 				var jwtUser = AuthTokenManager.GenerateToken(user, userSettings);
 				Logger.LogInformation(
 						$"{nameof(Login)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
@@ -92,99 +106,105 @@ namespace PrivaPub.Controllers.ClientToServer
 			}
 		}
 
-		//[HttpPost, Authorize(Policy = Policies.IsUser), AllowAnonymous]
-		//public async Task<IActionResult> InvitationSignUp(InvitationLoginForm signUpForm)
-		//{
-		//	if (User.Identity?.IsAuthenticated ?? false) return Redirect("/discussions");
-		//	var result = new WebResult();
-		//	if (!ModelState.IsValid)
-		//		return BadRequest(result.Invalidate(Localizer["Invalid model."]));
-		//	try
-		//	{
-		//		result = await DiscussionsService.GetInvitationConfiguration(signUpForm.InvitationCode, includePassword: true);
+		[HttpPost, Route("/clientapi/user/invitation/signup"), AllowAnonymous]
+		public async Task<IActionResult> InvitationSignUp(InvitationLoginForm signUpForm, CancellationToken token)
+		{
+			var result = new WebResult();
+			if (!ModelState.IsValid)
+				return BadRequest(result.Invalidate(Localizer["Invalid model."]));
+			try
+			{
+				var invitation = await GroupUsersService.GetInvitation(signUpForm.InvitationCode, signUpForm.InvitationPassword, token);
+				if (!invitation.IsValid)
+					return StatusCode(invitation.StatusCode, invitation);
 
-		//		if (!result.IsValid)
-		//			return StatusCode(result.StatusCode, result);
+				result = await UsersService.SignUpAsync(signUpForm, signUpForm.InvitationCode);
+				if (!result.IsValid)
+					return StatusCode(result.StatusCode, result);
+				var (user, userSettings) = ((RootUser, ViewUserSettings))result.Data;
 
-		//		var configuration = result.Data as InvitationConfiguration;
-		//		if (configuration.IsPasswordRequired && signUpForm.InvitationPassword != configuration.Password)
-		//		{
-		//			result.Invalidate(Localizer["Invalid password."], StatusCodes.Status406NotAcceptable);
-		//			return StatusCode(result.StatusCode, result);
-		//		}
+				var avatar = await AvatarUsersService.InsertAvatar(new InsertAvatarForm
+				{
+					RootId = user.ID,
+					Name = user.UserName,
+					UserName = user.UserName,
+					Biography = string.Empty
+				});
+				if (!avatar.IsValid)
+					return StatusCode(avatar.StatusCode, avatar);
 
-		//		result = await UsersService.SignUpAsync(new LoginForm
-		//		{
-		//			Username = signUpForm.Username,
-		//			Password = signUpForm.Password,
-		//			LightThemeIndexColour = signUpForm.ThemeIndexColour,
-		//			ThemeIsDarkMode = signUpForm.ThemeIsDarkMode,
-		//			InvitationPassword = signUpForm.InvitationPassword
-		//		}, signUpForm.InvitationCode, configuration.IsPasswordRequired);
-		//		if (!result.IsValid)
-		//			return StatusCode(result.StatusCode, result);
+				var joined = await GroupUsersService.JoinGroup(user.ID, new JoinGroupForm
+				{
+					AvatarId = ((ViewAvatar)avatar.Data).Id,
+					InvitationCode = signUpForm.InvitationCode,
+					InvitationPassword = signUpForm.InvitationPassword
+				}, token);
+				if (!joined.IsValid)
+					return StatusCode(joined.StatusCode, joined);
 
-		//		(var user, var userSettings) = ((User, ViewUserSettings))result.Data;
-		//		var jwtUser = AuthTokenManager.GenerateToken(user, userSettings);
-		//		Logger.LogInformation(
-		//			$"{nameof(InvitationSignUp)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
+				Logger.LogInformation(
+						$"{nameof(InvitationSignUp)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
+				return Ok(AuthTokenManager.GenerateToken(user, userSettings));
+			}
+			catch (Exception ex)
+			{
+				Logger.LogError(ex, $"{nameof(User)}.{nameof(InvitationSignUp)}()");
+				return BadRequest(result.Invalidate(ex.Message));
+			}
+		}
 
-		//		return Ok(jwtUser);
-		//	}
-		//	catch (Exception ex)
-		//	{
-		//		Logger.LogError(ex, $"{nameof(User)}.{nameof(InvitationSignUp)}()");
-		//		return BadRequest(result.Invalidate(ex.Message));
-		//	}
-		//}
+		[HttpPost, Route("/clientapi/user/invitation/login"), AllowAnonymous]
+		public async Task<IActionResult> InvitationLogin(InvitationLoginForm loginForm, CancellationToken token)
+		{
+			var result = new WebResult();
+			if (!ModelState.IsValid)
+				return BadRequest(result.Invalidate(Localizer["Invalid model."]));
+			try
+			{
+				var invitation = await GroupUsersService.GetInvitation(loginForm.InvitationCode, loginForm.InvitationPassword, token);
+				if (!invitation.IsValid)
+					return StatusCode(invitation.StatusCode, invitation);
 
-		//[HttpPost, Authorize(Policy = Policies.IsUser), AllowAnonymous]
-		//public async Task<IActionResult> InvitationLogin(InvitationLoginForm loginForm)
-		//{
-		//	if (User.Identity?.IsAuthenticated ?? false) return Redirect("/discussions" + loginForm.InvitationCode);
-		//	var result = new WebResult();
-		//	if (!ModelState.IsValid)
-		//		return BadRequest(result.Invalidate(Localizer["Invalid model."]));
-		//	try
-		//	{
-		//		result = await DiscussionsService.GetInvitationConfiguration(loginForm.InvitationCode, includePassword: true);
+				result = await UsersService.LoginAsync(loginForm, loginForm.InvitationCode);
+				if (!result.IsValid)
+					return StatusCode(result.StatusCode, result);
+				var (user, userSettings) = ((RootUser, ViewUserSettings))result.Data;
 
-		//		if (!result.IsValid)
-		//			return StatusCode(result.StatusCode, result);
+				var avatars = await AvatarUsersService.GetRootAvatars(user.ID, token);
+				var avatar = (avatars.Data as List<ViewAvatar>)?.FirstOrDefault();
+				if (avatar == default)
+				{
+					var inserted = await AvatarUsersService.InsertAvatar(new InsertAvatarForm
+					{
+						RootId = user.ID,
+						Name = user.UserName,
+						UserName = user.UserName,
+						Biography = string.Empty
+					});
+					if (!inserted.IsValid)
+						return StatusCode(inserted.StatusCode, inserted);
+					avatar = (ViewAvatar)inserted.Data;
+				}
 
-		//		var configuration = result.Data as InvitationConfiguration;
-		//		if (configuration.IsPasswordRequired && loginForm.InvitationPassword != configuration.Password)
-		//		{
-		//			result.Invalidate(Localizer["Invalid password."], StatusCodes.Status406NotAcceptable);
-		//			return StatusCode(result.StatusCode, result);
-		//		}
+				var joined = await GroupUsersService.JoinGroup(user.ID, new JoinGroupForm
+				{
+					AvatarId = avatar.Id,
+					InvitationCode = loginForm.InvitationCode,
+					InvitationPassword = loginForm.InvitationPassword
+				}, token);
+				if (!joined.IsValid)
+					return StatusCode(joined.StatusCode, joined);
 
-		//		result = await UsersService.LoginAsync(new LoginForm
-		//		{
-		//			Username = loginForm.Username,
-		//			Password = loginForm.Password,
-		//			ThemeIsDarkMode = loginForm.ThemeIsDarkMode,
-		//			LightThemeIndexColour = loginForm.ThemeIndexColour,
-		//			InvitationPassword = loginForm.InvitationPassword
-		//		}, loginForm.InvitationCode);
-
-		//		if (!result.IsValid)
-		//			return StatusCode(result.StatusCode, result);
-
-		//		var (user, userSettings/*, userCurrentTier*/) = ((User, ViewUserSettings/*, UserCurrentTier*/))result.Data;
-		//		var jwtUser = AuthTokenManager.GenerateToken(user, userSettings, 0
-		//			/*userCurrentTier == null ? default : (userCurrentTier.EndPeriod - DateTime.UtcNow).Days*/);
-		//		Logger.LogInformation(
-		//			$"{nameof(InvitationLogin)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
-
-		//		return Ok(jwtUser);
-		//	}
-		//	catch (Exception ex)
-		//	{
-		//		Logger.LogError(ex, $"{nameof(User)}.{nameof(InvitationLogin)}()");
-		//		return BadRequest(result.Invalidate(ex.Message));
-		//	}
-		//}
+				Logger.LogInformation(
+						$"{nameof(InvitationLogin)}();IP:[{HttpContext.Connection?.RemoteIpAddress}];\nUser-Agent:[{Request.Headers["User-Agent"]}];\nUserId:[{user.ID}]");
+				return Ok(AuthTokenManager.GenerateToken(user, userSettings));
+			}
+			catch (Exception ex)
+			{
+				Logger.LogError(ex, $"{nameof(User)}.{nameof(InvitationLogin)}()");
+				return BadRequest(result.Invalidate(ex.Message));
+			}
+		}
 
 		[HttpGet, Route("/clientapi/user/logout"), Authorize(Policy = Policies.IsUser)]
 		public IActionResult Logout()
@@ -223,7 +243,7 @@ namespace PrivaPub.Controllers.ClientToServer
 		}
 
 		[HttpPost, Route("/clientapi/user/update/settings"), Authorize(Policy = Policies.IsUser)]
-		public async Task<IActionResult> UpdateUserSettings(ViewAvatarServer userSettings)
+		public async Task<IActionResult> UpdateUserSettings(ViewUserSettings userSettings)
 		{
 			var result = new WebResult();
 			if (!ModelState.IsValid)
@@ -309,7 +329,9 @@ namespace PrivaPub.Controllers.ClientToServer
 				return BadRequest(result.Invalidate(Localizer["Invalid model."]));
 			try
 			{
-				var host = $"{Request.Scheme}://{Request.Host.Host}";
+				var host = string.IsNullOrEmpty(AppConfiguration.CurrentValue.FrontendBaseAddress)
+					? $"{Request.Scheme}://{Request.Host.Host}"
+					: AppConfiguration.CurrentValue.FrontendBaseAddress.TrimEnd('/');
 				result = await UsersService.SetupAndSendRecoveryEmail(passwordRecoveryForm, host);
 				if (!result.IsValid)
 					return StatusCode(result.StatusCode, result);

PrivaPub/Controllers/ServerToServer/PeasantsController.cs

@@ -1,110 +1,154 @@
-using Markdig;
-
 using Microsoft.AspNetCore.Mvc;
 
-using PrivaPub.ClientModels.Resources;
-using PrivaPub.Extensions;
-using PrivaPub.Models.ActivityPub;
-using PrivaPub.Services;
+using MongoDB.Entities;
 
-using System.ComponentModel.DataAnnotations;
-using System.Text.Json;
+using PrivaPub.Models.Federation;
+using PrivaPub.Services.Federation;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using PostEntity = PrivaPub.Models.Post.Post;
 
 namespace PrivaPub.Controllers.ServerToServer
 {
-	[ApiController,
-		Route("peasants"), Produces("application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"; charset=utf-8")]
+	[ApiController, Route("peasants")]
 	public class PeasantsController : ControllerBase
 	{
-		readonly IGroupUsersService _groupUsersService;
+		const string ActivityContentType = "application/activity+json; charset=utf-8";
+		const int OutboxSize = 20;
 
-		public PeasantsController(IGroupUsersService groupUsersService)
+		readonly ILocalActorService _localActors;
+		readonly IInboxService _inbox;
+		readonly DbEntities _dbEntities;
+		readonly ILogger<PeasantsController> _logger;
+
+		public PeasantsController(ILocalActorService localActors, IInboxService inbox, DbEntities dbEntities,
+			ILogger<PeasantsController> logger)
 		{
-			_groupUsersService = groupUsersService;
+			_localActors = localActors;
+			_inbox = inbox;
+			_dbEntities = dbEntities;
+			_logger = logger;
 		}
 
 		[HttpGet, Route("{actor}")]
-		public async Task<IActionResult> GetActor(
-			[Required(ErrorMessageResourceName = "Required",
-			ErrorMessageResourceType = typeof(FieldsNameResource))] string actor,
-			CancellationToken cancellation)
+		public async Task<IActionResult> GetActor(string actor, CancellationToken token)
 		{
-			var getResult = await _groupUsersService.GetGroup(actor, cancellation);
-			if (!getResult.IsValid)
-				return StatusCode(getResult.StatusCode, getResult);
-
-			var actorResponse = new ActivityPubActor();
-			actorResponse.Context[1] = string.Format(actorResponse.Context[1].ToString(), HttpContext.Request.PathBase);
-			actorResponse.Id = HttpContext.GetHostWithPath();
-			actorResponse.ProfileURL = HttpContext.GetHostWithPath();
-			actorResponse.Inbox = $"{HttpContext.GetHostWithPath()}/mouth";
-			actorResponse.Outbox = $"{HttpContext.GetHostWithPath()}/anus";
-			actorResponse.Endpoints = new()
-			{
-				SharedInboxURL = $"{HttpContext.GetHostWithPath()}/human-centipede",
-				OAuthAuthorizationEndpoint = $"{HttpContext.GetHost()}/sniff/again",
-			};
-			actorResponse.PreferredUsername = actor;
-			actorResponse.Name = actor;
-
-			if (getResult.Data is DmGroup dmGroup)
-			{
-				actorResponse.Summary = Markdown.ToHtml(dmGroup.Description);
-				actorResponse.Published = dmGroup.CreationDate;
-			}
-			else if (getResult.Data is Group dbGroup)
-			{
-				actorResponse.Summary = Markdown.ToHtml(dbGroup.Description);
-				actorResponse.Published = dbGroup.CreationDate;
-			}
-
-			return Ok(actorResponse);
+			var local = await _localActors.FindByUserName(actor, token);
+			return local == default ? NotFound() : Activity(ActivityPubRenderer.Actor(local));
 		}
 
 		[HttpGet, Route("{actor}/anus")]
-		public async Task<IActionResult> Anus(
-			[FromQuery] bool? page,
-			[Required(ErrorMessageResourceName = "Required",
-			ErrorMessageResourceType = typeof(FieldsNameResource))] string actor)
+		public async Task<IActionResult> Outbox(string actor, CancellationToken token)
 		{
-			if (!page.HasValue)
-				return Ok(new ActivityPubOrderedCollection
+			var local = await _localActors.FindByUserName(actor, token);
+			if (local == default)
+				return NotFound();
+
+			var total = local.Kind == LocalActorKind.Group
+				? await DB.Default.CountAsync<PostEntity>(p => p.GroupId == local.Id, token)
+				: await DB.Default.CountAsync<PostEntity>(p => p.GroupUserId == local.Id && !p.IsFederatedCopy, token);
+
+			var latest = await (local.Kind == LocalActorKind.Group
+					? _dbEntities.Posts.Match(p => p.GroupId == local.Id)
+					: _dbEntities.Posts.Match(p => p.GroupUserId == local.Id && !p.IsFederatedCopy))
+				.Sort(p => p.CreationDate, Order.Descending)
+				.Limit(OutboxSize)
+				.ExecuteAsync(token);
+
+			var items = new List<JsonNode>();
+			foreach (var post in latest)
+			{
+				if (local.Kind == LocalActorKind.Group)
 				{
-					Id = HttpContext.Request.Path,
-					FirstItem = $"{HttpContext.GetHostWithPath()}?page=true",
-				});
+					items.Add(ActivityPubRenderer.Announce(local, post.ObjectURI, $"announce-{post.ID}"));
+					continue;
+				}
+				var group = string.IsNullOrEmpty(post.GroupId) ? default : await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);
+				var note = ActivityPubRenderer.Note(post, local, group, default);
+				items.Add(ActivityPubRenderer.Create(local, note, $"create-{post.ID}"));
+			}
 
+			return Activity(ActivityPubRenderer.OrderedCollection(local.Outbox, (int)total, items));
+		}
 
-			return Ok();
+		[HttpGet, Route("{actor}/followers")]
+		public async Task<IActionResult> Followers(string actor, CancellationToken token)
+		{
+			var local = await _localActors.FindByUserName(actor, token);
+			if (local == default)
+				return NotFound();
+			var count = await DB.Default.CountAsync<Follower>(
+				f => f.LocalActorId == local.Id && f.LocalActorKind == local.Kind && f.IsAccepted, token);
+			return Activity(ActivityPubRenderer.OrderedCollection(local.Followers, (int)count, default));
+		}
+
+		[HttpGet, Route("{actor}/following")]
+		public async Task<IActionResult> Following(string actor, CancellationToken token)
+		{
+			var local = await _localActors.FindByUserName(actor, token);
+			return local == default ? NotFound() : Activity(ActivityPubRenderer.OrderedCollection(local.Following, 0, Enumerable.Empty<JsonNode>()));
+		}
+
+		[HttpGet, Route("{actor}/posts/{postId}")]
+		public async Task<IActionResult> Post(string actor, string postId, CancellationToken token)
+		{
+			var local = await _localActors.FindByUserName(actor, token);
+			if (local == default || local.Kind != LocalActorKind.Person)
+				return NotFound();
+
+			var post = await _dbEntities.Posts
+				.Match(p => p.ID == postId && p.GroupUserId == local.Id && !p.IsFederatedCopy)
+				.ExecuteFirstAsync(token);
+			if (post == default)
+				return NotFound();
+
+			var group = string.IsNullOrEmpty(post.GroupId) ? default : await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);
+			var replyTo = await ReplyTarget(post.AnsweringToPostId, token);
+			var note = ActivityPubRenderer.Note(post, local, group, replyTo);
+			note["@context"] = ActivityPubRenderer.ActivityStreams;
+			return Activity(note);
 		}
 
 		[HttpPost, Route("{actor}/mouth")]
-		public async Task<IActionResult> Month(
-			[Required(ErrorMessageResourceName = "Required",
-			ErrorMessageResourceType = typeof(FieldsNameResource))] string actor,
-			[FromBody] JsonDocument json)
+		public async Task<IActionResult> Inbox(string actor, CancellationToken token)
 		{
-
-			return Ok();
+			var local = await _localActors.FindByUserName(actor, token);
+			if (local == default)
+				return NotFound();
+			return Answer(await _inbox.Receive(Request, local, token));
 		}
 
 		[HttpPost, Route("{actor}/human-centipede")]
-		public async Task<IActionResult> HumanCentipede(
-			[Required(ErrorMessageResourceName = "Required",
-			ErrorMessageResourceType = typeof(FieldsNameResource))] string actor,
-			[FromBody] JsonDocument json)
-		{
-
-			return Ok();
-		}
+		public async Task<IActionResult> ActorSharedInbox(string actor, CancellationToken token) =>
+			Answer(await _inbox.Receive(Request, default, token));
 
 		[HttpPost, Route("/human-centipede")]
-		public async Task<IActionResult> PublicHumanCentipede(
-			[FromBody] JsonDocument json)
-		{
+		public async Task<IActionResult> SharedInbox(CancellationToken token) =>
+			Answer(await _inbox.Receive(Request, default, token));
 
-			return Ok();
+		async Task<string> ReplyTarget(string answeringToPostId, CancellationToken token)
+		{
+			if (string.IsNullOrEmpty(answeringToPostId))
+				return default;
+			if (answeringToPostId.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+				return answeringToPostId;
+			return (await _dbEntities.Posts.MatchID(answeringToPostId).ExecuteFirstAsync(token))?.ObjectURI;
 		}
 
+		IActionResult Answer(InboxResult result)
+		{
+			if (result.Error != default)
+				_logger.LogInformation("Inbox refused with {Status}: {Error}", result.StatusCode, result.Error);
+			return result.Error == default ? StatusCode(result.StatusCode) : StatusCode(result.StatusCode, result.Error);
+		}
+
+		ContentResult Activity(JsonObject document) => new()
+		{
+			Content = document.ToJsonString(),
+			ContentType = ActivityContentType,
+			StatusCode = StatusCodes.Status200OK
+		};
 	}
 }

PrivaPub/Controllers/ServerToServer/UsersController.cs

@@ -1,69 +1,12 @@
-using Markdig;
-
 using Microsoft.AspNetCore.Mvc;
-using PrivaPub.ClientModels.Resources;
-using PrivaPub.Extensions;
-using PrivaPub.Models.ActivityPub;
-using PrivaPub.Models.Group;
-using PrivaPub.Services;
-
-using System.ComponentModel.DataAnnotations;
 
 namespace PrivaPub.Controllers.ServerToServer
 {
-	[ApiController,
-		Route("users"), Produces("application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"; charset=utf-8")]
+	[ApiController, Route("users")]
 	public class UsersController : ControllerBase
 	{
-		readonly IRootUsersService _rootUsersService;
-
-		public UsersController(IRootUsersService rootUsersService)
-		{
-			_rootUsersService = rootUsersService;
-		}
-
 		[HttpGet, Route("{actor}")]
-		public async Task<IActionResult> GetActor(
-			[Required(ErrorMessageResourceName = "Required",
-			ErrorMessageResourceType = typeof(FieldsNameResource))] string actor,
-			CancellationToken cancellation)
-		{
-			var getResult = await _groupUsersService.GetGroup(actor, cancellation);
-			if (!getResult.IsValid)
-				return StatusCode(getResult.StatusCode, getResult);
-
-			var actorResponse = new ActivityPubActor();
-			actorResponse.Context[1] = string.Format(actorResponse.Context[1].ToString(), HttpContext.Request.PathBase);
-			actorResponse.Id = $"{HttpContext.GetHost()}/peasants/{actor}";
-			actorResponse.ProfileURL = $"{HttpContext.GetHost()}/peasants/{actor}";
-			actorResponse.Inbox = $"{HttpContext.GetHost()}/peasants/{actor}/mouth";
-			actorResponse.Outbox = $"{HttpContext.GetHost()}/peasants/{actor}/anus";
-			actorResponse.Endpoints = new()
-			{
-				SharedInboxURL = $"{HttpContext.GetHost()}/peasants/{actor}/human-centipede",
-				OAuthAuthorizationEndpoint = $"{HttpContext.GetHost()}/sniff/again",
-			};
-			actorResponse.PreferredUsername = actor;
-			actorResponse.Name = actor;
-
-			if (getResult.Data is DmGroup dmGroup)
-			{
-				actorResponse.Summary = Markdown.ToHtml(dmGroup.Description);
-				actorResponse.Published = dmGroup.CreationDate;
-			}
-			else if (getResult.Data is Group dbGroup)
-			{
-				actorResponse.Summary = Markdown.ToHtml(dbGroup.Description);
-				actorResponse.Published = dbGroup.CreationDate;
-			}
-
-			return Ok(actorResponse);
-		}
-
-		#region Admin
-
-
-
-		#endregion
+		public IActionResult GetActor(string actor) =>
+			RedirectPermanent($"/peasants/{Uri.EscapeDataString(actor)}");
 	}
 }

PrivaPub/Controllers/ServerToServer/WellKnownController.cs

@@ -0,0 +1,96 @@
+using Microsoft.AspNetCore.Mvc;
+
+using MongoDB.Entities;
+
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.User;
+using PrivaPub.Services.Federation;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Controllers.ServerToServer
+{
+	[ApiController]
+	public class WellKnownController : ControllerBase
+	{
+		readonly ILocalActorService _localActors;
+		readonly DbEntities _dbEntities;
+
+		public WellKnownController(ILocalActorService localActors, DbEntities dbEntities)
+		{
+			_localActors = localActors;
+			_dbEntities = dbEntities;
+		}
+
+		[HttpGet, Route("/.well-known/webfinger")]
+		public async Task<IActionResult> WebFinger([FromQuery] string resource, CancellationToken token)
+		{
+			if (string.IsNullOrEmpty(resource))
+				return BadRequest();
+
+			LocalActor actor;
+			if (resource.StartsWith("acct:", StringComparison.OrdinalIgnoreCase))
+			{
+				var parts = resource[5..].TrimStart('@').Split('@');
+				var domain = new Uri(_localActors.BaseAddress).Authority;
+				if (parts.Length != 2 || !parts[1].Equals(domain, StringComparison.OrdinalIgnoreCase))
+					return NotFound();
+				actor = await _localActors.FindByUserName(parts[0], token);
+			}
+			else
+				actor = await _localActors.FindByUri(resource, token);
+
+			if (actor == default)
+				return NotFound();
+
+			var document = new JsonObject
+			{
+				["subject"] = $"acct:{actor.Handle}",
+				["aliases"] = new JsonArray(actor.Uri),
+				["links"] = new JsonArray(
+					new JsonObject { ["rel"] = "self", ["type"] = "application/activity+json", ["href"] = actor.Uri },
+					new JsonObject { ["rel"] = "http://webfinger.net/rel/profile-page", ["type"] = "text/html", ["href"] = actor.Uri })
+			};
+			return Content(document.ToJsonString(), "application/jrd+json; charset=utf-8");
+		}
+
+		[HttpGet, Route("/.well-known/nodeinfo")]
+		public IActionResult NodeInfoLinks()
+		{
+			var document = new JsonObject
+			{
+				["links"] = new JsonArray(new JsonObject
+				{
+					["rel"] = "http://nodeinfo.diaspora.software/ns/schema/2.0",
+					["href"] = $"{_localActors.BaseAddress}/nodeinfo/2.0"
+				})
+			};
+			return Content(document.ToJsonString(), "application/json; charset=utf-8");
+		}
+
+		[HttpGet, Route("/nodeinfo/2.0")]
+		public async Task<IActionResult> NodeInfo(CancellationToken token)
+		{
+			var users = await DB.Default.CountAsync<Avatar>(a => !a.DeletionAt.HasValue, token);
+			var posts = await DB.Default.CountAsync<PostEntity>(p => !p.IsFederatedCopy, token);
+			var document = new JsonObject
+			{
+				["version"] = "2.0",
+				["software"] = new JsonObject { ["name"] = "privapub", ["version"] = BuildInfo.Ref },
+				["protocols"] = new JsonArray("activitypub"),
+				["services"] = new JsonObject { ["inbound"] = new JsonArray(), ["outbound"] = new JsonArray() },
+				["openRegistrations"] = true,
+				["usage"] = new JsonObject
+				{
+					["users"] = new JsonObject { ["total"] = users },
+					["localPosts"] = posts
+				},
+				["metadata"] = new JsonObject()
+			};
+			return Content(document.ToJsonString(), "application/json; profile=\"http://nodeinfo.diaspora.software/ns/schema/2.0#\"; charset=utf-8");
+		}
+	}
+}