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
276 lines
10 KiB
C#
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
|
|
};
|
|
}
|
|
}
|