Implement Sending of Remote Posts with Visibility Modes (Private/Public) (#177)

**Description:**
This PR introduces functionality for creating and sending remote posts
to recipient servers based on the specified visibility modes:

1. **Private:** Post is sent exclusively only to the followers.
2. **Public:** Post is sent to all the followers servers along with the
list of followers and visibility metadata, enabling the recipient server
to propagate the post to its users accordingly.

Note: This PR covers only the sending side (outgoing posts). Handling
and propagation of incoming posts by the inbox handler on the receiver
side will be implemented separately.

**Changes:**

- Implemented remote post creation with visibility metadata
(private/public).
- Posts are dispatched to the recipient server inbox along with the
followers list and visibility metadata.
- Added logic ensuring private posts are targeted to specific remote
recipients only.

**Testing:**

- Verified outgoing private posts reach the correct recipient server
inbox.
- Confirmed outgoing public posts include the correct visibility data
and followers list.

Author: VamshiRajRj

server/src/main/java/edu/sjsu/moth/server/activitypub/message/ActivityPubMessage.java

@@ -11,7 +11,7 @@
 @NoArgsConstructor
 public abstract class ActivityPubMessage {
     @JsonProperty("@context")
-    private final String context = "https://www.w3.org/ns/activitystreams";
+    private String context = "https://www.w3.org/ns/activitystreams";
     private String id;
     private String type;
     private String actor;

server/src/main/java/edu/sjsu/moth/server/activitypub/message/CreateMessage.java

@@ -5,7 +5,9 @@
 
 import java.util.List;
 
+@Document("outbox")
 public class CreateMessage extends ActivityPubMessage {
+
     public NoteMessage object;
     public List<String> to;
     public List<String> cc;

server/src/main/java/edu/sjsu/moth/server/activitypub/message/NoteMessage.java

@@ -9,6 +9,8 @@
 import java.util.Map;
 
 @Data
+@NoArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
 public class NoteMessage {
 
     /**
@@ -65,12 +67,16 @@ public NoteMessage(String id, String summary, String inReplyTo, String published
     }
 
     @Data
+    @NoArgsConstructor
+    @JsonInclude(JsonInclude.Include.NON_NULL)
     public static class Replies {
         private String id;
         private String type = "Collection";
         private First first;
 
         @Data
+        @NoArgsConstructor
+        @JsonInclude(JsonInclude.Include.NON_NULL)
         public static class First {
             private String type = "CollectionPage";
             private String next;

server/src/main/java/edu/sjsu/moth/server/activitypub/service/OutboxService.java

@@ -9,7 +9,6 @@
 import edu.sjsu.moth.server.activitypub.message.CreateMessage;
 import edu.sjsu.moth.server.activitypub.message.NoteMessage;
 import edu.sjsu.moth.server.db.AccountRepository;
-import edu.sjsu.moth.server.db.Outbox;
 import edu.sjsu.moth.server.db.OutboxRepository;
 import lombok.extern.apachecommons.CommonsLog;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -39,44 +38,44 @@ public class OutboxService {
     AccountRepository accountRepository;
 
     private final ObjectMapper objectMapper;
-    
+
     @Autowired
     private OutboxRepository outboxRepository;
 
     public OutboxService() {
         this.objectMapper = new ObjectMapper();
     }
 
-    public Outbox buildCreateActivity(Status status) {
+    public CreateMessage buildCreateActivity(Status status) {
         String actorUrl = ActivityPubUtil.toActivityPubUserUrl(status.account.url);
         NoteMessage note = buildNoteMessage(status, actorUrl);
-        CreateMessage create = new CreateMessage(actorUrl, note);
-
-        // 5. Construct and return the persistence object
-        return new Outbox(create.getId(),                    // id of the Create activity
-                          create.getActor(),                 // the actor URL
-                          note.getPublished(),                       // timestamp
-                          create.to,                    // to array
-                          create.cc,                    // cc array
-                          note                       // full CreateMessage JSON
-        );
+
+        return new CreateMessage(actorUrl, note);
     }
 
     private NoteMessage buildNoteMessage(Status status, String actorUrl) {
         NoteMessage.Replies.First first = new NoteMessage.Replies.First();
         first.setNext(status.getUri() + "/replies?only_other_accounts=true&page=true");
         first.setPartOf(status.getUri() + "/replies");
         first.setItems(Collections.emptyList());
+        String cc = "";
+        String bcc = "";
+
+        if (status.visibility != null && status.visibility.equals("private")) {
+            cc = actorUrl + "/followers";
+            bcc = "";
+        } else {
+            cc = "https://www.w3.org/ns/activitystreams#Public";
+            bcc = actorUrl + "/followers";
+        }
 
         NoteMessage.Replies replies = new NoteMessage.Replies();
         replies.setId(status.getUri() + "/replies");
         replies.setFirst(first);
 
-        return new NoteMessage(status.getUri(), null, null, status.createdAt, status.getUrl(), actorUrl,
-                               List.of("https://www.w3.org/ns/activitystreams#Public"),
-                               List.of(actorUrl + "/followers"), status.sensitive, status.getUri(), null, status.text,
-                               status.content, Map.of("en", status.content), Collections.emptyList(),
-                               Collections.emptyList(), replies);
+        return new NoteMessage(status.getUri(), null, null, status.createdAt, status.getUrl(), actorUrl, List.of(cc),
+                               List.of(bcc), status.sensitive, status.getUri(), null, status.text, status.content,
+                               Map.of("en", status.content), Collections.emptyList(), Collections.emptyList(), replies);
     }
 
     public Mono<ResponseEntity<JsonNode>> getOutboxIndex(String username, String baseOutbox) {
@@ -106,9 +105,9 @@ public Mono<ResponseEntity<JsonNode>> getOutbox(String username, String actorUrl
         final String baseOutbox = actorUrl + "/outbox";
         return outboxRepository.findAllByActorOrderByPublishedAtDesc(actorUrl).collectList().flatMap(messages -> {
             // cursor‐style pagination
-            List<Outbox> pageItems = new ArrayList<>();
+            List<CreateMessage> pageItems = new ArrayList<>();
             boolean skipping = (minId != null);
-            for (Outbox msg : messages) {
+            for (CreateMessage msg : messages) {
                 if (skipping) {
                     if (msg.getId().equals(minId)) skipping = false;
                     continue;
@@ -136,7 +135,7 @@ public Mono<ResponseEntity<JsonNode>> getOutbox(String username, String actorUrl
             root.put("id", baseOutbox + queryString);
             root.put("type", "OrderedCollectionPage");
             if (!pageItems.isEmpty()) {
-                String statusUrl = pageItems.get(0).getObject().getId();
+                String statusUrl = pageItems.get(0).object.getId();
                 String statusId = statusUrl.substring(statusUrl.lastIndexOf('/') + 1);
                 String prevQs =
                         "?min_id=" + URLEncoder.encode(statusId, StandardCharsets.UTF_8) + "&limit=" + pageSize +
@@ -147,7 +146,7 @@ public Mono<ResponseEntity<JsonNode>> getOutbox(String username, String actorUrl
 
             // orderedItems
             ArrayNode items = root.putArray("orderedItems");
-            for (Outbox msg : pageItems) {
+            for (CreateMessage msg : pageItems) {
                 items.add(objectMapper.valueToTree(msg));
             }
             return Mono.just(ResponseEntity.ok().contentType(MediaType.parseMediaType("application/activity+json"))
@@ -157,5 +156,4 @@ public Mono<ResponseEntity<JsonNode>> getOutbox(String username, String actorUrl
             return Mono.just(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
         });
     }
-
 }

server/src/main/java/edu/sjsu/moth/server/db/OutboxRepository.java

@@ -6,10 +6,10 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-public interface OutboxRepository extends ReactiveMongoRepository<Outbox, String> {
+public interface OutboxRepository extends ReactiveMongoRepository<CreateMessage, String> {
 
     @Query("{ 'actor': ?0 }")
-    Flux<Outbox> findAllByActorOrderByPublishedAtDesc(String actor);
+    Flux<CreateMessage> findAllByActorOrderByPublishedAtDesc(String actor);
 
     @Query(value = "{ 'actor': ?0 }", count = true)
     Mono<Long> countAllByActor(String actor);

server/src/main/java/edu/sjsu/moth/server/service/StatusService.java

@@ -1,14 +1,21 @@
 package edu.sjsu.moth.server.service;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.querydsl.core.types.Ops;
 import com.querydsl.core.types.Path;
 import com.querydsl.core.types.dsl.BooleanExpression;
 import com.querydsl.core.types.dsl.Expressions;
-import edu.sjsu.moth.generated.QStatus;
 import edu.sjsu.moth.generated.SearchResult;
 import edu.sjsu.moth.generated.Status;
 import edu.sjsu.moth.generated.StatusEdit;
 import edu.sjsu.moth.generated.StatusSource;
+import edu.sjsu.moth.server.activitypub.ActivityPubUtil;
+import edu.sjsu.moth.server.activitypub.message.CreateMessage;
+import edu.sjsu.moth.server.activitypub.service.OutboxService;
 import edu.sjsu.moth.server.activitypub.service.OutboxService;
 import edu.sjsu.moth.server.db.AccountField;
 import edu.sjsu.moth.server.db.AccountRepository;
@@ -21,6 +28,8 @@
 import edu.sjsu.moth.server.db.StatusHistoryRepository;
 import edu.sjsu.moth.server.db.StatusMention;
 import edu.sjsu.moth.server.db.StatusRepository;
+import edu.sjsu.moth.generated.QStatus;
+import edu.sjsu.moth.server.util.MothConfiguration;
 import lombok.extern.apachecommons.CommonsLog;
 import org.bson.types.ObjectId;
 import org.jetbrains.annotations.NotNull;
@@ -30,11 +39,17 @@
 import org.springframework.security.core.userdetails.UsernameNotFoundException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
 
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
 import java.security.Principal;
 import java.util.ArrayList;
 import java.util.List;
 
+import static edu.sjsu.moth.server.util.Util.signAndSend;
+
 @Configuration
 @CommonsLog
 public class StatusService {
@@ -55,17 +70,19 @@ public class StatusService {
     AccountService accountService;
 
     @Autowired
-    StatusHistoryRepository statusHistoryRepository;
+    VisibilityService visibilityService;
 
     @Autowired
-    VisibilityService visibilityService;
+    StatusHistoryRepository statusHistoryRepository;
 
     @Autowired
     OutboxService outboxService;
 
     @Autowired
     OutboxRepository outboxRepository;
 
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
     public Mono<ArrayList<StatusEdit>> findHistory(String id) {
         return statusHistoryRepository.findById(id).map(edits -> edits.collection);
     }
@@ -150,11 +167,20 @@ public Mono<Status> save(Status status) {
             }));
         }
 
-        return mono.then(statusRepository.save(status)).flatMap(
-                savedStatus -> outboxRepository.save(outboxService.buildCreateActivity(savedStatus))
-                        .thenReturn(savedStatus)).flatMap(
-                s -> statusHistoryRepository.findById(s.id).defaultIfEmpty(new StatusEditCollection(s.id))
-                        .flatMap(sh -> statusHistoryRepository.save(sh.addEdit(s))).thenReturn(s));
+        return mono.then(statusRepository.save(status)).flatMap(savedStatus -> {
+            CreateMessage createMessage = outboxService.buildCreateActivity(savedStatus);
+            Flux<Void> fanOut = outboxRepository.save(createMessage)
+                    .thenMany(getRemoteFollowerInboxes(savedStatus.account.id).flatMapMany(Flux::fromIterable))
+                    .flatMap(inboxUrl -> sendCreate(createMessage, inboxUrl));
+
+            // schedule it on boundedElastic, Invoke and forget
+            fanOut.subscribeOn(Schedulers.boundedElastic()).subscribe();
+
+            return Mono.just(savedStatus);  // immediately return savedStatus
+        }).flatMap(savedStatus -> statusHistoryRepository.findById(savedStatus.id)
+                .defaultIfEmpty(new StatusEditCollection(savedStatus.id))
+                .flatMap(sh -> statusHistoryRepository.save(sh.addEdit(savedStatus))).thenReturn(savedStatus));
+
     }
 
     public Mono<ExternalStatus> saveExternal(ExternalStatus status) {
@@ -274,4 +300,51 @@ private String convertToHex(String payload) {
         return String.format("%1$24s", payload).replace(' ', '0');
     }
 
+    private Mono<List<String>> getRemoteFollowerInboxes(String accountId) {
+        String localDomain = MothConfiguration.mothConfiguration.getServerName();
+
+        return followRepository.findAllByFollowedId(accountId)       // Flux<Follow>
+                // get the raw “acct” handle
+                .map(f -> f.id.follower_id)                              // Mono<String> of "username@domain"
+                // extract the domain part
+                .map(handle -> {
+                    int at = handle.indexOf('@');
+                    if (at < 0 || at == handle.length() - 1) {
+                        // invalid handle, drop it
+                        return null;
+                    }
+                    return handle.substring(at + 1);
+                })
+                // drop any nulls or locals
+                .filter(domain -> domain != null && !domain.equals(localDomain))
+                // build the inbox URL
+                .map(domain -> "https://" + domain + "/inbox")
+                // avoid duplicates
+                .distinct()
+                // collect into a List<String>
+                .collectList();
+    }
+
+    public Mono<Void> sendCreate(CreateMessage create, String inboxUrl) {
+        // 1) build the JSON tree for signing & sending
+        ObjectNode createJson = objectMapper.valueToTree(create);
+
+        // 2) extract the local actor name from the actor URL
+        String actorUrl = create.getActor();
+        String actorName = URI.create(actorUrl).getPath()          // "/users/alice"
+                .substring("/users/".length());
+
+        // 3) fetch the actor’s private key, then sign & send
+        return accountService.getPrivateKey(actorName, /* localOnly= */ true).flatMap(privKey ->
+                                                                                              // signAndSend is your
+                                                                                              // existing method that
+                                                                                              // does HTTP Signature
+                                                                                              // + POST
+                                                                                              signAndSend(createJson,
+                                                                                                          actorUrl,
+                                                                                                          inboxUrl,
+                                                                                                          privKey));
+    }
+
 }
+

server/src/test/java/edu/sjsu/moth/controllers/StatusControllerTest.java

@@ -12,20 +12,19 @@
 import edu.sjsu.moth.IntegrationTest;
 import edu.sjsu.moth.generated.Status;
 import edu.sjsu.moth.server.MothServerMain;
+import edu.sjsu.moth.server.activitypub.message.CreateMessage;
 import edu.sjsu.moth.server.activitypub.message.NoteMessage;
 import edu.sjsu.moth.server.controller.StatusController;
 import edu.sjsu.moth.server.db.Account;
 import edu.sjsu.moth.server.db.AccountRepository;
 import edu.sjsu.moth.server.db.Follow;
 import edu.sjsu.moth.server.db.FollowRepository;
-import edu.sjsu.moth.server.db.Outbox;
 import edu.sjsu.moth.server.db.OutboxRepository;
 import edu.sjsu.moth.server.db.StatusRepository;
 import edu.sjsu.moth.server.db.TokenRepository;
 import edu.sjsu.moth.server.service.StatusService;
 import edu.sjsu.moth.server.util.MothConfiguration;
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -266,21 +265,22 @@ public void testOutboxDataSave() {
         }
 
         // 3) build the actor URL
-        String actorUrl = "https://" + MothConfiguration.mothConfiguration.getServerName() + "/users/" + statusCreator;
+        String actor = "https://" + MothConfiguration.mothConfiguration.getServerName() + "/users/" + statusCreator;
 
         // 4) fetch all outbox messages for this actor
-        List<Outbox> outboxList = outboxRepository.findAllByActorOrderByPublishedAtDesc(actorUrl).collectList().block();
+        List<CreateMessage> outboxList =
+                outboxRepository.findAllByActorOrderByPublishedAtDesc(actor).collectList().block();
+
 
         // 5) verify that we stored exactly one Create per post
         assertNotNull(outboxList, "Outbox list should not be null");
         assertEquals(visibilities.length, outboxList.size(), "Expected one outbox entry per status posted");
 
         // 6) spot‐check the contents of each stored activity
-        for (Outbox out : outboxList) {
-            NoteMessage activity = out.getObject();
+        for (CreateMessage out : outboxList) {
+            NoteMessage activity = out.object;
             assertEquals("Create", out.getType(), "Activity type must be Create");
-            assertEquals(actorUrl, out.getActor(), "Actor URL must match");
-
+            assertEquals(actor, out.getActor(), "Actor URL must match");
             assertEquals("Note", activity.getType(), "Object type must be Note");
             assertTrue(activity.getContent().contains("This is a"), "Note content missing");
         }