Vamshi/centralize activity pub messages (#172)

**Summary**
This PR extends our new centralized ActivityPub message layer to fully
support both incoming and outgoing Follow/Unfollow workflows, with
correct state transitions for local vs. remote users, auto-accept logic,
and count updates. It also introduces a set of message classes for
JSON-LD formatting.

---

**New Message Layer**

* Extracted common ActivityPub logic into a `MessageService` to
centralize serialization. This lays the groundwork for handling other
ActivityPub message types (Like, Create, Announce, etc.) using the same
centralized layer.
* Created a base `ActivityPubMessage` plus concrete `FollowMessage`,
`AcceptMessage`, and `UndoMessage` classes to emit JSON-LD–compliant
ActivityPub payloads.

---

**Follow Handling**

* **Incoming**

  * Receive and validate incoming `Follow` activities.
* **Local users**: auto-accept the follow, persist the relation,
increment follower/following counts.
* **Remote users**: persist the relation, then send an `AcceptMessage`
back.
* **Outgoing**

  * On initiating a follow, build and send a `FollowMessage`.
* **Remote targets**: transition to **FOLLOWING** only after receiving
an `Accept` response from the remote server.
* **Local targets**: skip the request step and go straight to
**FOLLOWING**.

---

**Unfollow Handling**

* **Incoming**

  * Receive and validate incoming `Undo` (`Unfollow`) activities.
  * Decrement follower/following counts and remove the follow relation.
  * (Per spec, no Accept is sent for Undo.)
* **Outgoing**

  * Build and send an `UndoMessage` when the user unfollows.
  * **Remote targets**: remove the relation once the message is sent.
  * **Local targets**: remove immediately.

---

**State Management & Counts**

* Use `updateFollowersCount` and `updateFollowingCount` helpers to
recalculate and persist both users’ `followers_count` and
`following_count` after any follow/unfollow event.

---

**Impact & Next Steps**

* Lays the foundation for additional ActivityPub types (Like, Create,
Announce, etc.) using the same `MessageService`.
* Future work will Introduce a `Status` enum (`REQUESTED`, `ACCEPTED`)
on the `Follow` entity.

Author: VamshiRajRj

server/src/main/java/edu/sjsu/moth/server/activitypub/ActivityPubUtil.java

@@ -0,0 +1,64 @@
+package edu.sjsu.moth.server.activitypub;
+
+import edu.sjsu.moth.server.util.MothConfiguration;
+
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+
+public class ActivityPubUtil {
+
+    public static String inboxUrlToAcct(String inboxUrl) {
+        URI uri = URI.create(inboxUrl);
+        String host = uri.getHost();
+        String path = uri.getPath();
+        String[] segments = path.split("/");
+
+        if (segments.length < 2) {
+            throw new IllegalArgumentException("Invalid inbox URL format: " + inboxUrl);
+        }
+
+        String username = segments[segments.length - 1];
+
+        if (!isRemoteUser(inboxUrl)) {
+            return username;
+        } else {
+            return username + "@" + host;
+        }
+    }
+
+    public static String getActorUrl(String id) {
+        return String.format("https://%s/users/%s", MothConfiguration.mothConfiguration.getServerName(), id);
+    }
+
+    public static String getRemoteDomain(String uri) {
+        try {
+            return new URL(uri).getHost();
+        } catch (MalformedURLException e) {
+            return null;
+        }
+    }
+
+    public static boolean isRemoteUser(String actor) {
+        String domain = getRemoteDomain(actor);
+        String localDomain = MothConfiguration.mothConfiguration.getServerName();
+
+        if (domain == null) {
+            return false;
+        }
+
+        return !domain.equals(localDomain);
+    }
+
+    //Just some local implementations until I figure out the actual requirement and middleware
+    public static String toActivityPubUserUrl(String url) {
+        if (url == null || !url.contains("/@")) {
+            throw new IllegalArgumentException("Invalid Mastodon-style URL");
+        }
+
+        String baseUrl = url.substring(0, url.indexOf("/@"));
+        String username = url.substring(url.indexOf("/@") + 2); // Skip "/@"
+        return baseUrl + "/users/" + username;
+    }
+
+}

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

@@ -0,0 +1,13 @@
+package edu.sjsu.moth.server.activitypub.message;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+public class AcceptMessage extends ActivityPubMessage {
+    //Accept message accepts an Object for the object parameter
+    public JsonNode object;
+
+    public AcceptMessage(String actor, JsonNode object) {
+        super("Accept", actor);
+        this.object = object;
+    }
+}

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

@@ -0,0 +1,25 @@
+package edu.sjsu.moth.server.activitypub.message;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import edu.sjsu.moth.server.util.MothConfiguration;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.UUID;
+
+@Data
+@NoArgsConstructor
+public abstract class ActivityPubMessage {
+    @JsonProperty("@context")
+    private final String context = "https://www.w3.org/ns/activitystreams";
+    private String id;
+    private String type;
+    private String actor;
+
+    protected ActivityPubMessage(String type, String actor) {
+        this.type = type;
+        this.actor = actor;
+        this.id =
+                String.format("https://%s/%s", MothConfiguration.mothConfiguration.getServerName(), UUID.randomUUID());
+    }
+}

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

@@ -0,0 +1,11 @@
+package edu.sjsu.moth.server.activitypub.message;
+
+public class FollowMessage extends ActivityPubMessage {
+    //Follow message accepts a String for the object parameter
+    public String object;
+
+    public FollowMessage(String actor, String object) {
+        super("Follow", actor);
+        this.object = object;
+    }
+}

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

@@ -0,0 +1,13 @@
+package edu.sjsu.moth.server.activitypub.message;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+public class UndoMessage extends ActivityPubMessage {
+    //Follow message accepts a String for the object parameter
+    public JsonNode object;
+
+    public UndoMessage(JsonNode object) {
+        super("Undo", object.get("actor").asText());
+        this.object = object;
+    }
+}

server/src/main/java/edu/sjsu/moth/server/controller/AccountController.java

@@ -26,13 +26,15 @@
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.security.Principal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -46,7 +48,7 @@ public class AccountController {
     @Autowired
     private final FollowService followService;
 
-    public AccountController(AccountService accountService,FollowService followService) {
+    public AccountController(AccountService accountService, FollowService followService) {
         this.accountService = accountService;
         this.followService = followService;
     }
@@ -145,7 +147,6 @@ public Mono<ResponseEntity<List<Relationship>>> getApiV1AccountsRelationships(Pr
                                     .collect(Collectors.toList());
                     return Flux.merge(relationshipMonos).collectList().map(ResponseEntity::ok);
                 });
-
     }
 
     // spec: https://docs.joinmastodon.org/methods/accounts/#get
@@ -172,18 +173,28 @@ public Mono<ArrayList<Account>> getBlocks(Integer max_id, Integer since_id, Inte
 
     //Follow request sent out to other instances/ other users
     @PostMapping("/api/v1/accounts/{id}/follow")
-    public Mono<ResponseEntity<Relationship>> followUser(@PathVariable("id") String followedId, Principal user) {
-
-        return accountService.getAccountById(user.getName()).flatMap(a -> followService.followUser(a.id, followedId))
-                .map(ResponseEntity::ok);
+    public Mono<ResponseEntity<Object>> followUser(@PathVariable("id") String followedId, Principal user) {
+        return followService.followUser(user.getName(), followedId)
+                .map(rel -> ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body((Object) rel))
+                .onErrorResume(ResponseStatusException.class, ex -> {
+                    Map<String, String> errorBody =
+                            Map.of("error", ex.getStatusCode().toString(), "message", ex.getReason());
+                    return Mono.just(ResponseEntity.status(ex.getStatusCode()).contentType(MediaType.APPLICATION_JSON)
+                                             .body((Object) errorBody));
+                });
     }
 
     //Follow request sent out to other instances/ other users
     @PostMapping("/api/v1/accounts/{id}/unfollow")
-    public Mono<ResponseEntity<Relationship>> unfollowUser(@PathVariable("id") String followedId, Principal user) {
-
-        return accountService.getAccountById(user.getName()).flatMap(a -> followService.unfollowUser(a.id, followedId))
-                .map(ResponseEntity::ok);
+    public Mono<ResponseEntity<Object>> unfollowUser(@PathVariable("id") String followedId, Principal user) {
+        return followService.unfollowUser(user.getName(), followedId)
+                .map(rel -> ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body((Object) rel))
+                .onErrorResume(ResponseStatusException.class, ex -> {
+                    Map<String, String> errorBody =
+                            Map.of("error", ex.getStatusCode().toString(), "message", ex.getReason());
+                    return Mono.just(ResponseEntity.status(ex.getStatusCode()).contentType(MediaType.APPLICATION_JSON)
+                                             .body((Object) errorBody));
+                });
     }
 
 //    @GetMapping("/api/v1/accounts/{id}/following")

server/src/main/java/edu/sjsu/moth/server/controller/InboxController.java

@@ -162,10 +162,21 @@ public Mono<Actor> createActor(String accountLink) {
     @PostMapping("/users/{id}/inbox")
     public Mono<String> usersInbox(@PathVariable String id, @RequestBody JsonNode inboxNode) {
         String requestType = inboxNode.get("type").asText();
-        // follow or unfollow requests
-        if (requestType.equals("Follow") || requestType.equals("Undo"))
-            return accountService.followerHandler(id, inboxNode, requestType);
-        return Mono.empty();
+        // follow or unfollow requests from other or same instances
+        switch (requestType) {
+            case "Follow" -> {
+                return accountService.followerHandler(id, inboxNode,false);
+            }
+            case "Undo"->{
+                return accountService.followerHandler(id, inboxNode,true);
+            }
+            case "Accept" -> {
+                return accountService.acceptHandler(id,inboxNode);
+            }
+            default -> {
+                return Mono.empty();
+            }
+        }
     }
 
     @GetMapping("/users/{id}/following")