FEATURE: Allow Categories to follow remote Actors

app/controllers/concerns/discourse_activity_pub/signature_verification.rb

@@ -189,7 +189,7 @@ def actor_from_key_id(key_id)
         actor = DiscourseActivityPubActor.find_by(ap_id: ap_id)
 
         if !actor
-          ap_actor = AP::Actor.resolve_and_store(ap_id, stored: false)
+          ap_actor = AP::Actor.resolve_and_store(ap_id)
           actor = ap_actor.stored if ap_actor
         end
       end

app/controllers/discourse_activity_pub/actor_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DiscourseActivityPub
+  class ActorController < ApplicationController
+    before_action :ensure_admin
+    before_action :ensure_site_enabled
+    before_action :find_actor
+    before_action :find_target_actor, only: [:follow, :unfollow]
+
+    def follow
+      if !@actor.can_follow?(@target_actor)
+        return render_actor_error("cant_follow_target_actor", 401)
+      end
+
+      if FollowHandler.follow(@actor.id, @target_actor.id)
+        render json: success_json
+      else
+        render json: failed_json
+      end
+    end
+
+    def unfollow
+      if !@actor.following?(@target_actor)
+        return render_actor_error("not_following_target_actor", 404)
+      end
+
+      if FollowHandler.unfollow(@actor.id, @target_actor.id)
+        render json: success_json
+      else
+        render json: failed_json
+      end
+    end
+
+    def find_by_handle
+      params.require(:handle)
+
+      handle_actor = DiscourseActivityPubActor.find_by_handle(params[:handle])
+
+      if handle_actor
+        handle_actor_follow = handle_actor.follow_followers.find_by(follower_id: @actor.id)
+        handle_actor.followed_at = handle_actor_follow.followed_at if handle_actor_follow
+
+        render_serialized(handle_actor, DiscourseActivityPub::ActorSerializer)
+      else
+        render json: failed_json
+      end
+    end
+
+    protected
+
+    def find_actor
+      @actor = DiscourseActivityPubActor.find_by_id(params.require(:actor_id))
+      return render_actor_error("actor_not_found", 404) unless @actor.present?
+    end
+
+    def find_target_actor
+      @target_actor = DiscourseActivityPubActor.find_by_id(params[:target_actor_id])
+      return render_actor_error("target_actor_not_found", 404) unless @target_actor.present?
+    end
+
+    def ensure_site_enabled
+      render_actor_error("not_enabled", 403) unless DiscourseActivityPub.enabled
+    end
+
+    def render_actor_error(key, status)
+      render_json_error I18n.t("discourse_activity_pub.actor.error.#{key}"), status: status
+    end
+  end
+end

app/controllers/discourse_activity_pub/ap/activities_controller.rb

@@ -2,6 +2,7 @@
 
 class DiscourseActivityPub::AP::ActivitiesController < DiscourseActivityPub::AP::ObjectsController
   before_action :ensure_activity_exists
+  before_action :ensure_can_access_base_object
 
   def show
     render json: @activity.ap.json
@@ -10,6 +11,14 @@ def show
   protected
 
   def ensure_activity_exists
-    render_activity_pub_error("not_found", 404) unless @activity = DiscourseActivityPubActivity.find_by(ap_key: params[:key])
+    unless @activity = DiscourseActivityPubActivity.find_by(ap_key: params[:key])
+      render_activity_pub_error("not_found", 404)
+    end
+  end
+
+  def ensure_can_access_base_object
+    if @activity.base_object.nil? || !guardian.can_see?(@activity.base_object.model)
+      render_activity_pub_error("not_available", 401)
+    end
   end
 end

app/controllers/discourse_activity_pub/ap/collections_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class DiscourseActivityPub::AP::CollectionsController < DiscourseActivityPub::AP::ObjectsController
+  before_action :ensure_collection_exists
+  before_action :ensure_can_access_collection
+
+  def show
+    render json: @collection.ap.json
+  end
+
+  protected
+
+  def ensure_collection_exists
+    unless @collection = DiscourseActivityPubCollection.find_by(ap_key: params[:key], local: true)
+      render_activity_pub_error("not_found", 404)
+    end
+  end
+
+  def ensure_can_access_collection
+    render_activity_pub_error("not_available", 401) unless guardian.can_see?(@collection.model)
+  end
+end

app/controllers/discourse_activity_pub/ap/inboxes_controller.rb

@@ -20,6 +20,6 @@ def rate_limit
   end
 
   def process_json
-    Jobs.enqueue(:discourse_activity_pub_process, json: @json)
+    Jobs.enqueue(:discourse_activity_pub_process, json: @json, delivered_to: @actor.ap_id)
   end
 end

app/controllers/discourse_activity_pub/ap/shared_inboxes_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class DiscourseActivityPub::AP::SharedInboxesController < DiscourseActivityPub::AP::ObjectsController
+  def create
+    @json = validate_json_ld(request.body.read)
+
+    if @json
+      process_json
+      head 202
+    else
+      render_activity_pub_error("json_not_valid", 422)
+    end
+  end
+
+  protected
+
+  def rate_limit
+    limit = SiteSetting.activity_pub_rate_limit_post_to_inbox_per_minute
+    RateLimiter.new(nil, "activity-pub-inbox-post-min-#{request.remote_ip}", limit, 1.minute).performed!
+  end
+
+  def process_json
+    Jobs.enqueue(:discourse_activity_pub_process, json: @json)
+  end
+end

app/controllers/discourse_activity_pub/category_controller.rb

@@ -12,31 +12,67 @@ class CategoryController < ApplicationController
     def index
     end
 
+    def follows
+      guardian.ensure_can_edit!(@category)
+
+      actors.each do |actor|
+        actor.followed_at = actor.follow_followers&.first.followed_at
+      end
+
+      render_actors
+    end
+
     def followers
       guardian.ensure_can_see!(@category)
 
-      followers = @category
-        .activity_pub_followers
-        .joins(:follow_follows)
-        .where(follow_follows: { followed_id: @category.activity_pub_actor.id })
-        .left_joins(:user)
-        .order("#{order_table}.#{order} #{params[:asc] ? "ASC" : "DESC"} NULLS LAST")
+      actors.each do |actor|
+        actor.followed_at = actor.follow_follows&.first.followed_at
+      end
+
+      render_actors
+    end
 
-      limit = fetch_limit_from_params(default: PAGE_SIZE, max: PAGE_SIZE)
-      page = fetch_int_from_params(:page, default: 0)
-      total = followers.count
-      followers = followers.limit(limit).offset(limit * page).to_a
+    protected
 
+    def render_actors
       render_json_dump(
-        followers: serialize_data(followers, FollowerSerializer, root: false),
+        actors: serialize_data(actors, ActorSerializer, root: false),
         meta: {
-          total: total,
-          load_more_url: load_more_url(page),
+          total: @total,
+          load_more_url: load_more_url(@page),
         }
       )
     end
 
-    protected
+    def actors
+      @actors ||= begin
+        actors = self.send("#{action_name}_actors")
+          .left_joins(:user)
+          .order("#{order_table}.#{order} #{params[:asc] ? "ASC" : "DESC"} NULLS LAST")
+
+        limit = fetch_limit_from_params(default: PAGE_SIZE, max: PAGE_SIZE)
+        @page = fetch_int_from_params(:page, default: 0)
+        @total = actors.count
+
+        actors.limit(limit).offset(limit * @page).to_a
+      end
+    end
+
+    def follows_actors
+      @follows_actors ||=
+        @category
+          .activity_pub_follows
+          .joins(:follow_followers)
+          .where(follow_followers: { follower_id: @category.activity_pub_actor.id })
+    end
+
+    def followers_actors
+      @followers_actors ||=
+        @category
+          .activity_pub_followers
+          .joins(:follow_follows)
+          .where(follow_follows: { followed_id: @category.activity_pub_actor.id })
+    end
 
     def permitted_order
       @permitted_order ||= ORDER.find { |attr| attr == params[:order] }

app/controllers/discourse_activity_pub/webfinger/handle_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DiscourseActivityPub
+  class Webfinger
+    class HandleController < WebfingerController
+      def validate
+        params.require(:handle)
+
+        handle = Webfinger::Handle.new(handle: params[:handle])
+
+        render json: { valid: handle.valid? }
+      end
+    end
+  end
+end

app/controllers/discourse_activity_pub/webfinger_controller.rb

@@ -5,7 +5,7 @@ class WebfingerController < ApplicationController
     skip_before_action :preload_json, :redirect_to_login_if_required, :check_xhr
 
     before_action :ensure_site_enabled
-    before_action :find_resource
+    before_action :find_resource, only: [:index]
 
     def index
       # TODO: is this Cache Control correct for webfinger?

app/jobs/discourse_activity_pub_deliver.rb

@@ -11,25 +11,27 @@ class DiscourseActivityPubDeliver < ::Jobs::Base
     def execute(args)
       @args = args
       return unless perform_request?
+      before_perform_request
       perform_request
+      after_perform_request
     end
 
     private
 
     def perform_request
-      @performed = false
+      @delivered = false
       retry_count = @args[:retry_count] || 0
 
       # TODO (future): use request in a Request Pool
       request = DiscourseActivityPub::Request.new(
         actor_id: from_actor.id,
-        uri: to_actor.inbox,
-        body: delivery_object.ap.json
+        uri: @args[:send_to],
+        body: delivery_json
       )
 
       # TODO (future): raise redirects from Request and resolve with FinalDestination
       if request&.post_json_ld
-        @performed = true
+        @delivered = true
       else
         retry_count += 1
         return if retry_count > MAX_RETRY_COUNT
@@ -38,10 +40,11 @@ def perform_request
         ::Jobs.enqueue_in(delay.minutes, :discourse_activity_pub_deliver, @args.merge(retry_count: retry_count))
       end
     ensure
-      if @performed
+      if @delivered
+        log_success
         failure_tracker.track_success
-        object.after_deliver
       else
+        log_failure
         failure_tracker.track_failure
       end
     end
@@ -55,27 +58,26 @@ def perform_request?
     end
 
     def has_required_args?
-      %i[object_id object_type from_actor_id to_actor_id].all? { |s| @args.key? s }
+      %i[from_actor_id send_to].all? { |key| @args[key].present? }
     end
 
     def failure_tracker
-      @failure_tracker ||= DiscourseActivityPub::DeliveryFailureTracker.new(to_actor.inbox)
+      @failure_tracker ||= DiscourseActivityPub::DeliveryFailureTracker.new(@args[:send_to])
     end
 
     def object
-      @object ||= @args[:object_type].constantize.find_by(id: @args[:object_id])
+      @object ||= begin
+        return nil unless @args[:object_type] && @args[:object_id]
+        @args[:object_type].constantize.find_by(id: @args[:object_id])
+      end
     end
 
     def from_actor
       @from_actor ||= DiscourseActivityPubActor.find_by(id: @args[:from_actor_id])
     end
 
-    def to_actor
-      @to_actor ||= DiscourseActivityPubActor.find_by(id: @args[:to_actor_id])
-    end
-
     def actors_ready?
-      from_actor&.ready? && to_actor&.ready?
+      from_actor&.ready?
     end
 
     def object_ready?
@@ -93,7 +95,7 @@ def delivery_object
         if announcing?
           begin
             object.announce!(from_actor.id)
-            object.announcement
+            object
           rescue PG::UniqueViolation, ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
             log_failure(e.message)
           end
@@ -103,10 +105,31 @@ def delivery_object
       end
     end
 
-    def log_failure(message)
+    def delivery_json
+      @delivery_json ||= begin
+        final_object = announcing? ? delivery_object.announcement : delivery_object
+        final_object.ap.json
+      end
+    end
+
+    def log_failure(message = "Failed to POST")
       return false unless SiteSetting.activity_pub_verbose_logging
-      prefix = "#{from_actor.ap_id} failed to deliver #{object&.ap_id}"
+      prefix = "#{from_actor.ap_id} failed to deliver #{JSON.generate(delivery_json)}"
       Rails.logger.warn("[Discourse Activity Pub] #{prefix}: #{message}")
     end
+
+    def log_success
+      return false unless SiteSetting.activity_pub_verbose_logging
+      prefix = "JSON delivered to #{@args[:send_to]}"
+      Rails.logger.warn("[Discourse Activity Pub] #{prefix}: #{JSON.generate(delivery_json)}")
+    end
+
+    def before_perform_request
+      object.before_deliver if object.present?
+    end
+
+    def after_perform_request
+      object.after_deliver(@delivered) if object.present?
+    end
   end
 end