Files
SocialPub/PrivaPub/Services/PostsService.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

276 lines
10 KiB
C#

using Microsoft.Extensions.Localization;
using MongoDB.Driver;
using MongoDB.Entities;
using PrivaPub.ClientModels;
using PrivaPub.ClientModels.Post;
using PrivaPub.Models.Federation;
using PrivaPub.Models.Group;
using PrivaPub.Models.Post;
using PrivaPub.Models.Social;
using PrivaPub.Resources;
using PrivaPub.StaticServices;
using System.Text.Json.Nodes;
using PostEntity = PrivaPub.Models.Post.Post;
using PrivaPub.Domain.Privacy;
using PrivaPub.Domain.Statuses;
using PrivaPub.Domain.Timelines;
using PrivaPub.Federation.Actors;
using PrivaPub.Federation.Rendering;
using PrivaPub.Federation.Outbox;
namespace PrivaPub.Services
{
public interface IPostsService
{
Task<WebResult> InsertPost(string rootUserId, InsertPostForm form, CancellationToken token);
Task<WebResult> DeletePost(string rootUserId, DeletePostForm form, CancellationToken token);
Task<WebResult> UpdatePost(string rootUserId, UpdatePostForm form, CancellationToken token);
Task<WebResult> Nearby(string rootUserId, string avatarId, double latitude, double longitude, CancellationToken token);
Task<WebResult> GetPosts(string rootUserId, string avatarId, string groupId, CancellationToken token);
Task<WebResult> InsertDm(string rootUserId, InsertDmForm form, CancellationToken token);
Task<WebResult> GetDms(string rootUserId, string avatarId, string dmGroupId, CancellationToken token);
}
public class PostsService(
DbEntities dbEntities,
ILocalActorService localActors,
IStatusService statuses,
IStringLocalizer<GenericRes> localizer,
ILogger<PostsService> logger) : IPostsService
{
const int PageSize = 50;
public async Task<WebResult> InsertPost(string rootUserId, InsertPostForm form, CancellationToken token)
{
var author = await OwnedAvatar(rootUserId, form.AvatarId, token);
if (author == default)
return new WebResult().Invalidate(29001.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
return await Answer(() => statuses.Publish(author, new StatusDraft
{
Text = form.Text,
Title = form.Title,
SpoilerText = form.SpoilerText,
Sensitive = form.HasContentWarning,
Visibility = LocalVisibility(form.Visibility),
InReplyTo = form.AnsweringToPostId,
GroupId = form.GroupId,
Latitude = form.Latitude,
Longitude = form.Longitude,
RangeKm = form.RangeKm
}, token), nameof(InsertPost), token);
}
public async Task<WebResult> DeletePost(string rootUserId, DeletePostForm form, CancellationToken token)
{
var author = await OwnedAvatar(rootUserId, form.AvatarId, token);
if (author == default)
return new WebResult().Invalidate(29002.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var result = await Answer(() => statuses.Remove(author, form.PostId, token), nameof(DeletePost), token);
result.Data = default;
return result;
}
public async Task<WebResult> UpdatePost(string rootUserId, UpdatePostForm form, CancellationToken token)
{
var author = await OwnedAvatar(rootUserId, form.AvatarId, token);
if (author == default)
return new WebResult().Invalidate(29003.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
return await Answer(() => statuses.Edit(author, form.PostId, new StatusDraft
{
Text = form.Text,
Title = form.Title,
SpoilerText = form.SpoilerText,
Sensitive = form.HasContentWarning
}, token), nameof(UpdatePost), token);
}
public async Task<WebResult> GetPosts(string rootUserId, string avatarId, string groupId, CancellationToken token)
{
var result = new WebResult();
try
{
var avatar = await OwnedAvatar(rootUserId, avatarId, token);
if (avatar == default)
return result.Invalidate(29004.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
var query = dbEntities.Posts;
if (string.IsNullOrEmpty(groupId))
query.Match(p => p.GroupUserId == avatar.Id && p.Visibility != PostVisibility.Direct);
else
{
var isMember = await dbEntities.Groups
.Match(g => g.ID == groupId && g.Members.Any(m => !m.IsForeign && m.AvatarId == avatar.Id))
.ExecuteAnyAsync(token);
if (!isMember)
return result.Invalidate(29005.ToCodedError(localizer["Group not found."]), StatusCodes.Status404NotFound);
query.Match(p => p.GroupId == groupId);
}
var posts = await query.Match(VisibilityPolicy.IsShown).Sort(p => p.CreationDate, Order.Descending).Limit(PageSize).ExecuteAsync(token);
result.Data = posts.Where(p => !VisibilityPolicy.Barred(p)).Select(ToView).ToList();
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(PostsService)}.{nameof(GetPosts)}");
return result.Invalidate(29006.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> InsertDm(string rootUserId, InsertDmForm form, CancellationToken token)
{
var author = await OwnedAvatar(rootUserId, form.AvatarId, token);
if (author == default)
return new WebResult().Invalidate(29007.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
if (string.IsNullOrEmpty(form.DmGroupId) && form.Recipients.Count == 0)
return new WebResult().Invalidate(29008.ToCodedError(localizer["At least one recipient is required."]));
return await Answer(() => statuses.Publish(author, new StatusDraft
{
Text = form.Text,
Sensitive = form.HasContentWarning,
Visibility = PostVisibility.Direct,
ConversationId = form.DmGroupId,
Recipients = form.Recipients
}, token), nameof(InsertDm), token);
}
public async Task<WebResult> GetDms(string rootUserId, string avatarId, string dmGroupId, CancellationToken token)
{
var result = new WebResult();
try
{
var avatar = await OwnedAvatar(rootUserId, avatarId, token);
if (avatar == default)
return result.Invalidate(29009.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
if (string.IsNullOrEmpty(dmGroupId))
{
var groups = await dbEntities.DmGroups
.Match(g => !g.DeletionAt.HasValue && g.Members.Any(m => !m.IsForeign && m.AvatarId == avatar.Id))
.Sort(g => g.UpdatedAt, Order.Descending)
.ExecuteAsync(token);
result.Data = groups.Select(g => new ViewDmGroup
{
Id = g.ID,
Members = g.Members.Select(m => m.AvatarId).ToList(),
UpdatedAt = g.UpdatedAt
}).ToList();
return result;
}
var isMember = await dbEntities.DmGroups
.Match(g => g.ID == dmGroupId && g.Members.Any(m => !m.IsForeign && m.AvatarId == avatar.Id))
.ExecuteAnyAsync(token);
if (!isMember)
return result.Invalidate(29010.ToCodedError(localizer["Conversation not found."]), StatusCodes.Status404NotFound);
var dms = await dbEntities.Posts
.Match(p => p.ConversationId == dmGroupId && p.Visibility == PostVisibility.Direct)
.Match(VisibilityPolicy.IsShown)
.Sort(p => p.CreationDate, Order.Descending)
.Limit(PageSize)
.ExecuteAsync(token);
result.Data = dms.Where(p => !VisibilityPolicy.Barred(p)).Select(ToView).ToList();
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(PostsService)}.{nameof(GetDms)}");
return result.Invalidate(29011.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> Nearby(string rootUserId, string avatarId, double latitude, double longitude, CancellationToken token)
{
var result = new WebResult();
var viewer = await OwnedAvatar(rootUserId, avatarId, token);
if (viewer == default)
return result.Invalidate(29012.ToCodedError(localizer["Avatar not found."]), StatusCodes.Status404NotFound);
if (latitude is < -90 or > 90 || longitude is < -180 or > 180)
return result.Invalidate(29013.ToCodedError(localizer["Invalid model."]));
var query = new MongoDB.Bson.BsonDocument
{
["Visibility"] = (int)PostVisibility.LocalGeo,
["DeletedAt"] = MongoDB.Bson.BsonNull.Value
};
var candidates = await DB.Default.GeoNear<PostEntity>(new Coordinates2D(longitude, latitude), p => p.Distance, true, 50_000, default, default, query)
.Limit(200)
.ToListAsync(token);
var near = candidates.Where(p => p.Distance <= p.RangeKm * 1000).ToList();
var hidden = await Domain.Relationships.Hidden.AuthorsHiddenFrom(viewer.Id, near.Select(p => p.ActorURI), forNotifications: false, token);
result.Data = near.Where(p => !hidden.Contains(p.ActorURI)).Select(p =>
{
var view = ToView(p);
view.RangeKm = p.RangeKm;
view.DistanceKm = Math.Round(p.Distance.Value / 1000, 1);
return view;
}).ToList();
return result;
}
async Task<WebResult> Answer(Func<Task<StatusOutcome>> action, string operation, CancellationToken token = default)
{
var result = new WebResult();
try
{
var outcome = await action();
if (!outcome.Ok)
return result.Invalidate(29014.ToCodedError(localizer[outcome.Error]), outcome.Status);
result.Data = ToView(outcome.Post);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, "{Service}.{Operation}", nameof(PostsService), operation);
return result.Invalidate(29015.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
static PostVisibility LocalVisibility(string requested) => requested?.ToLowerInvariant() switch
{
"unlisted" => PostVisibility.Unlisted,
"followersonly" or "private" => PostVisibility.FollowersOnly,
_ => PostVisibility.Public
};
async Task<LocalActor> OwnedAvatar(string rootUserId, string avatarId, CancellationToken token)
{
if (string.IsNullOrEmpty(rootUserId) || string.IsNullOrEmpty(avatarId))
return default;
if (!await dbEntities.RootToAvatars.Match(ra => ra.RootId == rootUserId && ra.AvatarId == avatarId).ExecuteAnyAsync(token))
return default;
// a suspended persona does nothing through the client API either (R6)
return await localActors.FindById(LocalActorKind.Person, avatarId, token) is { Suspended: false } persona ? persona : default;
}
static ViewPost ToView(PostEntity post) => new()
{
Id = post.ID,
ObjectURI = post.ObjectURI,
AuthorAvatarId = post.IsFederatedCopy ? default : post.GroupUserId,
AuthorActorURI = post.ActorURI,
GroupId = post.GroupId,
DmGroupId = post.ConversationId,
Visibility = post.Visibility.ToString(),
AnsweringToPostId = post.AnsweringToPostId,
Title = post.Title,
Text = post.Text,
ContentHtml = post.ContentHtml,
HasContentWarning = post.HasContentWarning,
IsFederatedCopy = post.IsFederatedCopy,
CreationDate = post.CreationDate
};
}
}