Files
SocialPub/PrivaPub/Services/GroupUsersService.cs
T
thepraandClaude Opus 5.5 c2f439d1e9
Build / Build (push) Successful in 34s
Deploy / privapub.thepra.dev (push) Successful in 57s
Deploy / Release notes on the Releases tab (push) Successful in 3s
Every failure the server answers with names its own error code
Each refusal and failure the client API sends now starts with a code no other failure uses, such as "[ERR0030006] That
code is not valid.", so a screenshot or a report points at the exact place it came from. Nothing another program reads
changes: ActivityPub, the Mastodon API's errors, sign-in tokens and the error kinds decePubClient branches on stay as they
were. The house-rules checks move to 1.1.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W4YtEJrgxG12Pc39Fai8Bd
2026-11-10 08:11:24 +01:00

501 lines
22 KiB
C#

using Microsoft.Extensions.Localization;
using MongoDB.Entities;
using PrivaPub.ClientModels;
using PrivaPub.ClientModels.Group;
using PrivaPub.Models.Federation;
using PrivaPub.Models.Group;
using PrivaPub.Resources;
using PrivaPub.StaticServices;
using GroupEntity = PrivaPub.Models.Group.Group;
using PrivaPub.Federation.Actors;
using PrivaPub.Federation.Rendering;
using PrivaPub.Federation.Outbox;
namespace PrivaPub.Services
{
public interface IGroupUsersService
{
Task<WebResult> GetGroups(string rootUserId, string avatarId, CancellationToken token);
Task<WebResult> InsertGroup(string rootUserId, InsertGroupForm form, CancellationToken token);
Task<WebResult> UpdateGroup(string rootUserId, UpdateGroupForm form, CancellationToken token);
Task<WebResult> JoinGroup(string rootUserId, JoinGroupForm form, CancellationToken token);
Task<WebResult> LeaveGroup(string rootUserId, GroupMembershipForm form, CancellationToken token);
Task<WebResult> ApproveMember(string rootUserId, GroupMembershipForm form, CancellationToken token);
Task<WebResult> GetMembers(string rootUserId, string avatarId, string groupId, CancellationToken token);
Task<WebResult> RejectMember(string rootUserId, GroupMembershipForm form, CancellationToken token);
Task<WebResult> RemoveMember(string rootUserId, GroupMembershipForm form, CancellationToken token);
Task<WebResult> GetInvitation(string invitationCode, string invitationPassword, CancellationToken token);
}
public class GroupUsersService(
DbEntities dbEntities,
IPasswordHasher passwordHasher,
ILocalActorService localActors,
IDeliveryService delivery,
IStringLocalizer<GenericRes> localizer,
ILogger<GroupUsersService> logger,
Domain.Media.IMediaProxy mediaProxy) : IGroupUsersService
{
public async Task<WebResult> GetGroups(string rootUserId, string avatarId, CancellationToken token)
{
var result = new WebResult();
try
{
if (!await OwnsAvatar(rootUserId, avatarId, token))
return result.Invalidate(27001.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var groups = await dbEntities.Groups
.Match(g => !g.DeletionAt.HasValue && g.Members.Any(m => !m.IsForeign && m.AvatarId == avatarId))
.ExecuteAsync(token);
result.Data = groups.Select(g => ToView(g, avatarId)).ToList();
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(GetGroups)}");
return result.Invalidate(27002.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> InsertGroup(string rootUserId, InsertGroupForm form, CancellationToken token)
{
var result = new WebResult();
try
{
if (!await OwnsAvatar(rootUserId, form.AvatarId, token))
return result.Invalidate(27003.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var userName = form.UserName.ToLowerInvariant();
if (await localActors.IsUserNameTaken(userName, token))
return result.Invalidate(27004.ToCodedError(localizer["The username '{0}' is already taken.", userName]));
var (privateKey, publicKey) = Keys.NewKeyPair();
var group = new GroupEntity
{
UserName = userName,
Name = form.Name,
Description = form.Description,
Domain = localActors.BaseAddress,
PrivateKey = privateKey,
PublicKey = publicKey,
Kind = form.IsCommunity ? GroupKind.Community : GroupKind.Circle,
PostingPolicy = Policy(form.PostingPolicy) ?? PostingPolicy.Followers,
IsDiscoverable = form.IsDiscoverable,
ManuallyApprovesMembers = form.ManuallyApprovesMembers,
OwnerAvatarId = form.AvatarId,
InvitationCode = NewInvitationCode(),
HashedInvitationPassword = string.IsNullOrEmpty(form.InvitationPassword) ? default : passwordHasher.Hash(form.InvitationPassword),
Members = new() { new GroupMember { AvatarId = form.AvatarId, Role = GroupRole.Owner } }
};
group.ID = (string)group.GenerateNewID();
if (!await localActors.TryReserveUserName(userName, LocalActorKind.Group, group.ID, token))
return result.Invalidate(27005.ToCodedError(localizer["The username '{0}' is already taken.", userName]));
var actor = localActors.FromGroup(group);
group.Url = actor.Uri;
group.InboxURL = actor.Inbox;
group.OutboxURL = actor.Outbox;
await DB.Default.SaveAsync(group, token);
result.Data = ToView(group, form.AvatarId);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(InsertGroup)}");
return result.Invalidate(27006.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> UpdateGroup(string rootUserId, UpdateGroupForm form, CancellationToken token)
{
var result = new WebResult();
try
{
var group = await ManagedGroup(rootUserId, form.AvatarId, form.GroupId, token);
if (group == default)
return result.Invalidate(27007.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
if (form.Name != default)
group.Name = form.Name;
if (form.Description != default)
group.Description = form.Description;
if (form.IsDiscoverable.HasValue)
group.IsDiscoverable = form.IsDiscoverable.Value;
if (Policy(form.PostingPolicy) is { } policy)
group.PostingPolicy = policy;
if (form.ManuallyApprovesMembers.HasValue)
group.ManuallyApprovesMembers = form.ManuallyApprovesMembers.Value;
if (form.RemoveInvitationPassword)
group.HashedInvitationPassword = default;
else if (!string.IsNullOrEmpty(form.InvitationPassword))
group.HashedInvitationPassword = passwordHasher.Hash(form.InvitationPassword);
if (form.RegenerateInvitationCode)
group.InvitationCode = NewInvitationCode();
group.UpdatedAt = DateTime.UtcNow;
await DB.Default.SaveAsync(group, token);
result.Data = ToView(group, form.AvatarId);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(UpdateGroup)}");
return result.Invalidate(27008.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> JoinGroup(string rootUserId, JoinGroupForm form, CancellationToken token)
{
var result = new WebResult();
try
{
if (!await OwnsAvatar(rootUserId, form.AvatarId, token))
return result.Invalidate(27009.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var group = await dbEntities.Groups
.Match(g => g.InvitationCode == form.InvitationCode && !g.DeletionAt.HasValue)
.ExecuteFirstAsync(token);
if (group == default)
return result.Invalidate(27010.ToCodedError(localizer["Invalid invitation."]), StatusCodes.Status404NotFound);
if (!string.IsNullOrEmpty(group.HashedInvitationPassword))
{
var (verified, _) = string.IsNullOrEmpty(form.InvitationPassword)
? (false, false)
: passwordHasher.Check(group.HashedInvitationPassword, form.InvitationPassword);
if (!verified)
return result.Invalidate(27011.ToCodedError(localizer["Invalid password."]), StatusCodes.Status406NotAcceptable);
}
if (!group.Members.Any(m => !m.IsForeign && m.AvatarId == form.AvatarId))
{
group.Members.Add(new GroupMember { AvatarId = form.AvatarId });
group.UpdatedAt = DateTime.UtcNow;
await DB.Default.SaveAsync(group, token);
}
await FollowAsMember(group, form.AvatarId, token);
result.Data = ToView(group, form.AvatarId);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(JoinGroup)}");
return result.Invalidate(27012.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// Joining by invitation is following, as a local follow of the group would be: the member counts among its
// followers (so /groupies and /flock agree) and gets its posts in the home timeline.
async Task FollowAsMember(GroupEntity group, string avatarId, CancellationToken token)
{
var persona = await localActors.FindById(LocalActorKind.Person, avatarId, token);
var target = localActors.FromGroup(group);
if (persona == default)
return;
await DB.Default.Update<Follower>()
.Match(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && f.ActorURI == persona.Uri)
.Modify(f => f.InboxURL, persona.Inbox)
.Modify(f => f.SharedInboxURL, persona.SharedInbox)
.Modify(f => f.IsAccepted, true)
.Modify(b => b.SetOnInsert(f => f.CreationDate, DateTime.UtcNow))
.Option(o => o.IsUpsert = true)
.ExecuteAsync(token);
await DB.Default.Update<Models.Social.Following>()
.Match(f => f.AvatarId == persona.Id && f.TargetActorURI == target.Uri)
.Modify(f => f.TargetAccountId, group.ID)
.Modify(f => f.TargetIsLocal, true)
.Modify(f => f.TargetInboxURL, target.Inbox)
.Modify(f => f.State, Models.Social.FollowState.Accepted)
.Modify(b => b.SetOnInsert(f => f.CreatedAt, DateTime.UtcNow))
.Option(o => o.IsUpsert = true)
.ExecuteAsync(token);
}
public async Task<WebResult> LeaveGroup(string rootUserId, GroupMembershipForm form, CancellationToken token)
{
var result = new WebResult();
try
{
if (!await OwnsAvatar(rootUserId, form.AvatarId, token))
return result.Invalidate(27013.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var group = await dbEntities.Groups.MatchID(form.GroupId).ExecuteFirstAsync(token);
if (group == default)
return result.Invalidate(27014.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
if (group.OwnerAvatarId == form.AvatarId)
return result.Invalidate(27015.ToCodedError(localizer["The owner cannot leave the group."]));
group.Members.RemoveAll(m => !m.IsForeign && m.AvatarId == form.AvatarId);
group.UpdatedAt = DateTime.UtcNow;
await DB.Default.SaveAsync(group, token);
// leaving is unfollowing, as joining was following
var groupUri = localActors.FromGroup(group).Uri;
var personaUri = (await localActors.FindById(LocalActorKind.Person, form.AvatarId, token))?.Uri;
await DB.Default.DeleteAsync<Models.Social.Following>(f => f.AvatarId == form.AvatarId && f.TargetActorURI == groupUri);
if (personaUri != default)
await DB.Default.DeleteAsync<Follower>(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && f.ActorURI == personaUri);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(LeaveGroup)}");
return result.Invalidate(27016.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> ApproveMember(string rootUserId, GroupMembershipForm form, CancellationToken token)
{
var result = new WebResult();
try
{
var group = await ManagedGroup(rootUserId, form.AvatarId, form.GroupId, token);
if (group == default)
return result.Invalidate(27017.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
var follower = await dbEntities.Followers
.Match(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && f.ActorURI == form.MemberActorURI)
.ExecuteFirstAsync(token);
if (follower == default)
return result.Invalidate(27018.ToCodedError(localizer["Request not found."]), StatusCodes.Status404NotFound);
follower.IsAccepted = true;
await DB.Default.SaveAsync(follower, token);
if (!group.Members.Any(m => m.IsForeign && m.AvatarId == follower.ActorURI))
{
group.Members.Add(new GroupMember { AvatarId = follower.ActorURI, IsForeign = true });
await DB.Default.SaveAsync(group, token);
}
var actor = localActors.FromGroup(group);
var follow = new System.Text.Json.Nodes.JsonObject
{
["id"] = follower.FollowActivityURI,
["type"] = "Follow",
["actor"] = follower.ActorURI,
["object"] = actor.Uri
};
var accept = ActivityPubRenderer.Accept(actor, follow, $"accept-{follower.ID}-{DateTime.UtcNow.Ticks}");
await delivery.Enqueue(actor, new[] { follower.InboxURL }, accept, token: token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(ApproveMember)}");
return result.Invalidate(27019.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> GetInvitation(string invitationCode, string invitationPassword, CancellationToken token)
{
var result = new WebResult();
var group = string.IsNullOrEmpty(invitationCode)
? default
: await dbEntities.Groups.Match(g => g.InvitationCode == invitationCode && !g.DeletionAt.HasValue).ExecuteFirstAsync(token);
if (group == default)
return result.Invalidate(27020.ToCodedError(localizer["Invalid invitation."]), StatusCodes.Status404NotFound);
if (!string.IsNullOrEmpty(group.HashedInvitationPassword)
&& (string.IsNullOrEmpty(invitationPassword) || !passwordHasher.Check(group.HashedInvitationPassword, invitationPassword).verified))
return result.Invalidate(27021.ToCodedError(localizer["Invalid password."]), StatusCodes.Status406NotAcceptable);
result.Data = group;
return result;
}
// the group's members and the requests to join it, for its owner and moderators only: members are never shown to
// anyone else (FEDERATION.md, followers' members are never public)
public async Task<WebResult> GetMembers(string rootUserId, string avatarId, string groupId, CancellationToken token)
{
var result = new WebResult();
try
{
var group = await ManagedGroup(rootUserId, avatarId, groupId, token);
if (group == default)
return result.Invalidate(27022.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
var members = new List<ViewGroupMember>();
foreach (var member in group.Members)
{
if (member.IsForeign)
{
var foreign = await dbEntities.ForeignAvatars.Match(a => a.ActorURI == member.AvatarId).ExecuteFirstAsync(token);
members.Add(Remote(member.AvatarId, foreign, member.Role, member.JoinedAt, pending: false));
continue;
}
if (await localActors.FindById(LocalActorKind.Person, member.AvatarId, token) is { } local)
members.Add(new ViewGroupMember
{
ActorUri = local.Uri, Handle = local.Handle, Name = local.Name ?? local.UserName, PictureUrl = local.PictureURL,
IsLocal = true, Role = member.Role.ToString().ToLowerInvariant(), Since = member.JoinedAt
});
}
var asking = await dbEntities.Followers
.Match(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && !f.IsAccepted)
.Sort(f => f.CreationDate, Order.Ascending)
.ExecuteAsync(token);
foreach (var request in asking.Where(r => members.All(m => m.ActorUri != r.ActorURI)))
{
var foreign = await dbEntities.ForeignAvatars.Match(a => a.ActorURI == request.ActorURI).ExecuteFirstAsync(token);
members.Add(Remote(request.ActorURI, foreign, GroupRole.Member, request.CreationDate, pending: true));
}
result.Data = members;
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(GetMembers)}");
return result.Invalidate(27023.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// a remote member's picture through the media proxy, as everywhere else a client sees remote media
ViewGroupMember Remote(string actorUri, Models.User.ForeignAvatar foreign, GroupRole role, DateTime since, bool pending) => new()
{
ActorUri = actorUri,
Handle = foreign == default ? actorUri : $"{foreign.UserName}@{foreign.Domain}",
Name = foreign?.Name ?? foreign?.UserName,
PictureUrl = mediaProxy.Wrap(foreign?.PictureURL),
IsPending = pending,
Role = role.ToString().ToLowerInvariant(),
Since = since
};
// a request to join declined: the asker's server is told with a Reject of its Follow
public async Task<WebResult> RejectMember(string rootUserId, GroupMembershipForm form, CancellationToken token)
{
var result = new WebResult();
try
{
var group = await ManagedGroup(rootUserId, form.AvatarId, form.GroupId, token);
if (group == default)
return result.Invalidate(27024.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
var request = await dbEntities.Followers
.Match(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && f.ActorURI == form.MemberActorURI && !f.IsAccepted)
.ExecuteFirstAsync(token);
if (request == default)
return result.Invalidate(27025.ToCodedError(localizer["Request not found."]), StatusCodes.Status404NotFound);
await DB.Default.DeleteAsync<Follower>(request.ID);
await RejectFollow(group, request, token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(RejectMember)}");
return result.Invalidate(27026.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// a member taken out of the group: a persona here stops following it, someone elsewhere is told with a Reject of
// their Follow (as Mastodon removes a follower). The owner stays.
public async Task<WebResult> RemoveMember(string rootUserId, GroupMembershipForm form, CancellationToken token)
{
var result = new WebResult();
try
{
var group = await ManagedGroup(rootUserId, form.AvatarId, form.GroupId, token);
if (group == default)
return result.Invalidate(27027.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
var localMember = await localActors.FindByUri(form.MemberActorURI, token);
var member = group.Members.FirstOrDefault(m => localMember is { Kind: LocalActorKind.Person }
? !m.IsForeign && m.AvatarId == localMember.Id
: m.IsForeign && m.AvatarId == form.MemberActorURI);
if (member == default)
return result.Invalidate(27028.ToCodedError(localizer["Member not found."]), StatusCodes.Status404NotFound);
if (member.Role == GroupRole.Owner)
return result.Invalidate(27029.ToCodedError(localizer["The owner cannot leave the group."]));
group.Members.Remove(member);
group.UpdatedAt = DateTime.UtcNow;
await DB.Default.SaveAsync(group, token);
var follower = await dbEntities.Followers
.Match(f => f.LocalActorId == group.ID && f.LocalActorKind == LocalActorKind.Group && f.ActorURI == form.MemberActorURI)
.ExecuteFirstAsync(token);
if (follower != default)
await DB.Default.DeleteAsync<Follower>(follower.ID);
if (localMember is { Kind: LocalActorKind.Person })
{
var groupUri = localActors.FromGroup(group).Uri;
await DB.Default.DeleteAsync<Models.Social.Following>(f => f.AvatarId == localMember.Id && f.TargetActorURI == groupUri);
}
else if (follower != default)
await RejectFollow(group, follower, token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GroupUsersService)}.{nameof(RemoveMember)}");
return result.Invalidate(27030.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
async Task RejectFollow(GroupEntity group, Follower follower, CancellationToken token)
{
if (string.IsNullOrEmpty(follower.InboxURL))
return;
var actor = localActors.FromGroup(group);
var follow = new System.Text.Json.Nodes.JsonObject
{
["id"] = follower.FollowActivityURI,
["type"] = "Follow",
["actor"] = follower.ActorURI,
["object"] = actor.Uri
};
var reject = ActivityPubRenderer.Accept(actor, follow, $"reject-{follower.ID}-{DateTime.UtcNow.Ticks}");
reject["type"] = "Reject";
await delivery.Enqueue(actor, new[] { follower.InboxURL }, reject, token: token);
}
async Task<GroupEntity> ManagedGroup(string rootUserId, string avatarId, string groupId, CancellationToken token)
{
if (!await OwnsAvatar(rootUserId, avatarId, token))
return default;
var group = await dbEntities.Groups.MatchID(groupId).ExecuteFirstAsync(token);
if (group == default || group.DeletionAt.HasValue)
return default;
var role = group.Members.FirstOrDefault(m => !m.IsForeign && m.AvatarId == avatarId)?.Role;
return role is GroupRole.Owner or GroupRole.Moderator ? group : default;
}
// a suspended persona does nothing in its groups (R6)
async Task<bool> OwnsAvatar(string rootUserId, string avatarId, CancellationToken token) =>
!string.IsNullOrEmpty(rootUserId) && !string.IsNullOrEmpty(avatarId) && !Domain.Moderation.Restrictions.IsSuspended(avatarId)
&& await dbEntities.RootToAvatars.Match(ra => ra.RootId == rootUserId && ra.AvatarId == avatarId).ExecuteAnyAsync(token);
static PostingPolicy? Policy(string value) => value?.ToLowerInvariant() switch
{
"anyone" => PostingPolicy.Anyone,
"moderators" => PostingPolicy.Moderators,
"followers" => PostingPolicy.Followers,
_ => (PostingPolicy?)null
};
static string NewInvitationCode() => $"{Guid.NewGuid():N}{Guid.NewGuid():N}";
ViewGroup ToView(GroupEntity group, string avatarId)
{
var actor = localActors.FromGroup(group);
var isManager = group.Members.Any(m => !m.IsForeign && m.AvatarId == avatarId && m.Role is GroupRole.Owner or GroupRole.Moderator);
return new ViewGroup
{
Id = group.ID,
UserName = group.UserName,
Name = group.Name,
Description = group.Description,
Url = actor.Uri,
Handle = actor.Handle,
IsCommunity = group.Kind == GroupKind.Community,
PostingPolicy = group.PostingPolicy.ToString().ToLowerInvariant(),
IsDiscoverable = group.IsDiscoverable,
ManuallyApprovesMembers = group.ManuallyApprovesMembers,
IsOwner = group.OwnerAvatarId == avatarId,
InvitationCode = isManager ? group.InvitationCode : default,
IsPasswordRequired = !string.IsNullOrEmpty(group.HashedInvitationPassword),
MembersCount = group.Members.Count,
CreationDate = group.CreationDate
};
}
}
}