Likes and boosts arrive, count, notify, and can be taken back

- Like: a Favourite per account and post (unique), the post's counter, a
  Favourite notification for a local author; only on posts the liker
  could see (public and unlisted, or followers-only and direct when they
  were addressed).
- Announce: the original is always refetched from its own origin (or is
  ours), and must be public or unlisted. A boost of a local post counts
  and notifies; a boost by an account a persona follows is stored as a
  reblog row and fanned out to its followers' home timelines (as a reblog,
  where reblogs are wanted). A boost by a stranger of a stranger's post is
  ignored. FEP-1b12 group announces of activities wait for P4.
- Undo of a Like or an Announce reverses each of them; an Undo naming only
  an id is matched against follows, likes and boosts in turn.

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

PrivaPub/Federation/Inbox/Handlers/AnnounceHandler.cs

@@ -0,0 +1,106 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Social;
+using PrivaPub.Domain.Timelines;
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Objects;
+using PrivaPub.Infrastructure.Ids;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Globalization;
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Federation.Objects.ActivityJson;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Inbox.Handlers
+{
+	public class AnnounceHandler : IActivityHandler
+	{
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+		readonly IRemotePosts _remotePosts;
+		readonly IFanout _fanout;
+
+		public AnnounceHandler(DbEntities dbEntities, ILocalActorService localActors, IRemotePosts remotePosts, IFanout fanout)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+			_remotePosts = remotePosts;
+			_fanout = fanout;
+		}
+
+		public string Type => "Announce";
+
+		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
+		{
+			var inner = activity["object"];
+			if (inner is JsonObject && Value(inner, "type") is "Create" or "Update" or "Delete" or "Like" or "Dislike" or "Undo" or "Add" or "Remove" or "Block")
+				return;
+			var objectUri = Id(inner);
+			var announceId = Id(activity);
+			if (objectUri == default || announceId == default)
+				return;
+			if (await _dbEntities.Posts.Match(p => p.ObjectURI == announceId).ExecuteAnyAsync(token))
+				return;
+
+			var isLocal = objectUri.StartsWith(_localActors.BaseAddress + "/", StringComparison.OrdinalIgnoreCase);
+			var original = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri && !p.DeletedAt.HasValue && p.ReblogOfPostId == null).ExecuteFirstAsync(token);
+			var followed = await _dbEntities.Followings.Match(f => f.TargetActorURI == actor.ActorURI && f.State == FollowState.Accepted).ExecuteAnyAsync(token);
+			if (original is not { IsFederatedCopy: false } && !followed)
+				return;
+			if (original == default && !isLocal)
+				original = await _remotePosts.StoreContext(objectUri, 0, token);
+			if (original == default || original.Visibility is not (PostVisibility.Public or PostVisibility.Unlisted))
+				return;
+
+			var to = Strings(activity["to"]);
+			var cc = Strings(activity["cc"]);
+			var published = DateTimeOffset.TryParse(Value(activity, "published"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var at)
+				? at.UtcDateTime
+				: DateTime.UtcNow;
+			var reblog = new PostEntity
+			{
+				ID = PrivacyIds.At(published),
+				ObjectURI = announceId,
+				ActivityURI = announceId,
+				ActorURI = actor.ActorURI,
+				AuthorAccountId = actor.ID,
+				ReblogOfPostId = original.ID,
+				Visibility = Addressing.Classify(to, cc, actor.FollowersURL),
+				To = to,
+				Cc = cc,
+				IsFederatedCopy = true,
+				CreationDate = published,
+				UpdateDate = published
+			};
+			if (reblog.Visibility == PostVisibility.Direct)
+				return;
+			try
+			{
+				await DB.Default.SaveAsync(reblog, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+				return;
+			}
+
+			await DB.Default.Update<PostEntity>().MatchID(original.ID).Modify(b => b.Inc(p => p.ReblogsCount, 1)).ExecuteAsync(token);
+			if (!original.IsFederatedCopy)
+				await Notifications.Add(original.GroupUserId, NotificationType.Reblog, actor.ID, actor.ActorURI, original.ID, token);
+			await _fanout.Distribute(reblog, token);
+		}
+
+		static List<string> Strings(JsonNode node) => node switch
+		{
+			JsonArray array => array.Select(Id).Where(id => id != default).ToList(),
+			JsonNode single when Id(single) is { } id => new List<string> { id },
+			_ => new List<string>()
+		};
+	}
+}

PrivaPub/Federation/Inbox/Handlers/LikeHandler.cs

@@ -0,0 +1,56 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Social;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Federation.Objects.ActivityJson;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Inbox.Handlers
+{
+	public class LikeHandler : IActivityHandler
+	{
+		readonly DbEntities _dbEntities;
+
+		public LikeHandler(DbEntities dbEntities)
+		{
+			_dbEntities = dbEntities;
+		}
+
+		public string Type => "Like";
+
+		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
+		{
+			var objectUri = Id(activity["object"]);
+			var post = objectUri == default
+				? default
+				: await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri && !p.DeletedAt.HasValue && p.ReblogOfPostId == null).ExecuteFirstAsync(token);
+			if (post == default || !MaySee(post, actor))
+				return;
+
+			try
+			{
+				await DB.Default.SaveAsync(new Favourite { AccountId = actor.ID, ActorURI = actor.ActorURI, PostId = post.ID, ActivityURI = Id(activity) }, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+				return;
+			}
+			await DB.Default.Update<PostEntity>().MatchID(post.ID).Modify(b => b.Inc(p => p.FavouritesCount, 1)).ExecuteAsync(token);
+			if (!post.IsFederatedCopy)
+				await Notifications.Add(post.GroupUserId, NotificationType.Favourite, actor.ID, actor.ActorURI, post.ID, token);
+		}
+
+		public static bool MaySee(PostEntity post, ForeignAvatar actor) =>
+			post.Visibility is PostVisibility.Public or PostVisibility.Unlisted
+			|| post.Visibility is PostVisibility.FollowersOnly or PostVisibility.Direct
+				&& (post.To.Contains(actor.ActorURI) || post.Cc.Contains(actor.ActorURI) || post.Mentions.Any(m => m.ActorURI == actor.ActorURI));
+	}
+}

PrivaPub/Federation/Inbox/Handlers/UndoHandler.cs

@@ -1,12 +1,8 @@
 using MongoDB.Entities;
 
 using PrivaPub.Federation.Actors;
-using PrivaPub.Federation.Objects;
-using PrivaPub.Federation.Outbox;
-using PrivaPub.Federation.Rendering;
 using PrivaPub.Models.Federation;
-using PrivaPub.Models.Group;
-using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Models.User;
 using PrivaPub.StaticServices;
 
@@ -23,38 +19,37 @@ namespace PrivaPub.Federation.Inbox.Handlers
 	{
 		readonly DbEntities _dbEntities;
 		readonly ILocalActorService _localActors;
-		readonly IRemoteActorService _remoteActors;
-		readonly IDeliveryService _delivery;
 
-		public UndoHandler(DbEntities dbEntities, ILocalActorService localActors, IRemoteActorService remoteActors, IDeliveryService delivery)
+		public UndoHandler(DbEntities dbEntities, ILocalActorService localActors)
 		{
 			_dbEntities = dbEntities;
 			_localActors = localActors;
-			_remoteActors = remoteActors;
-			_delivery = delivery;
 		}
 
 		public string Type => "Undo";
 
 		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
 		{
-			var undo = activity;
-
-			var inner = undo["object"];
+			var inner = activity["object"];
 			var innerType = inner is JsonObject ? Value(inner, "type") : default;
 			var innerId = Id(inner);
 
-			if (inner is JsonObject && Id(inner["actor"]) != actor.ActorURI)
-				return;
-			if (innerType is not (null or "Follow"))
-				return;
+			if (innerType is null or "Follow")
+				await UndoFollow(inner, innerId, actor, token);
+			if (innerType is null or "Like")
+				await UndoLike(inner, innerId, actor, token);
+			if (innerType is null or "Announce")
+				await UndoAnnounce(innerId, actor, token);
+		}
 
+		async Task UndoFollow(JsonNode inner, string innerId, ForeignAvatar actor, CancellationToken token)
+		{
 			var followers = await _dbEntities.Followers.Match(f => f.ActorURI == actor.ActorURI).ExecuteAsync(token);
 			var targetUri = inner is JsonObject ? Id(inner["object"]) : default;
+			var target = targetUri == default ? default : await _localActors.FindByUri(targetUri, token);
 			foreach (var follower in followers)
 			{
 				var matchesActivity = innerId != default && follower.FollowActivityURI == innerId;
-				var target = targetUri == default ? default : await _localActors.FindByUri(targetUri, token);
 				var matchesTarget = target != default && target.Id == follower.LocalActorId && target.Kind == follower.LocalActorKind;
 				if (!matchesActivity && !matchesTarget)
 					continue;
@@ -63,7 +58,38 @@ namespace PrivaPub.Federation.Inbox.Handlers
 				if (follower.LocalActorKind == LocalActorKind.Group)
 					await RemoveForeignMember(follower.LocalActorId, actor.ActorURI, token);
 			}
-			return;
-				}
+		}
+
+		async Task UndoLike(JsonNode inner, string innerId, ForeignAvatar actor, CancellationToken token)
+		{
+			var favourite = innerId == default
+				? default
+				: await _dbEntities.Favourites.Match(f => f.ActivityURI == innerId && f.ActorURI == actor.ActorURI).ExecuteFirstAsync(token);
+			if (favourite == default && inner is JsonObject && Id(inner["object"]) is { } objectUri)
+			{
+				var post = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri).ExecuteFirstAsync(token);
+				favourite = post == default
+					? default
+					: await _dbEntities.Favourites.Match(f => f.PostId == post.ID && f.ActorURI == actor.ActorURI).ExecuteFirstAsync(token);
+			}
+			if (favourite == default)
+				return;
+			await DB.Default.DeleteAsync<Favourite>(favourite.ID);
+			await DB.Default.Update<PostEntity>().MatchID(favourite.PostId).Modify(b => b.Inc(p => p.FavouritesCount, -1)).ExecuteAsync(token);
+		}
+
+		async Task UndoAnnounce(string innerId, ForeignAvatar actor, CancellationToken token)
+		{
+			if (innerId == default)
+				return;
+			var reblog = await _dbEntities.Posts
+				.Match(p => p.ObjectURI == innerId && p.ActorURI == actor.ActorURI && p.ReblogOfPostId != null)
+				.ExecuteFirstAsync(token);
+			if (reblog == default)
+				return;
+			await DB.Default.DeleteAsync<PostEntity>(reblog.ID);
+			await DB.Default.DeleteAsync<TimelineEntry>(e => e.PostId == reblog.ID);
+			await DB.Default.Update<PostEntity>().MatchID(reblog.ReblogOfPostId).Modify(b => b.Inc(p => p.ReblogsCount, -1)).ExecuteAsync(token);
+		}
 	}
 }

PrivaPub/Middleware/SocialPubConfigurations.cs

@@ -65,6 +65,8 @@ namespace PrivaPub.Middleware
 				.AddSingleton<IActivityHandler, AcceptHandler>()
 				.AddSingleton<IActivityHandler, RejectHandler>()
 				.AddSingleton<IActivityHandler, UndoHandler>()
+				.AddSingleton<IActivityHandler, LikeHandler>()
+				.AddSingleton<IActivityHandler, AnnounceHandler>()
 				.AddSingleton<IActivityHandler, CreateHandler>()
 				.AddSingleton<IActivityHandler, DeleteHandler>()
 				.AddSingleton<IActivityHandler, UpdateHandler>()