Fix following groups + Add interface to manage followers

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/federation/activity_pub/activity_pub.ex

@@ -50,7 +50,6 @@ defmodule Mobilizon.Federation.ActivityPub do
 
   alias Mobilizon.Web.Endpoint
   alias Mobilizon.Web.Email.{Admin, Group, Mailer}
-  alias Mobilizon.Web.Email.Follow, as: FollowMailer
 
   require Logger
 
@@ -320,13 +319,22 @@ defmodule Mobilizon.Federation.ActivityPub do
   @doc """
   Make an actor follow another
   """
-  def follow(%Actor{} = follower, %Actor{} = followed, activity_id \\ nil, local \\ true) do
+  def follow(
+        %Actor{} = follower,
+        %Actor{} = followed,
+        activity_id \\ nil,
+        local \\ true,
+        additional \\ %{}
+      ) do
     with {:different_actors, true} <- {:different_actors, followed.id != follower.id},
-         {:ok, %Follower{} = follower} <-
-           Actors.follow(followed, follower, activity_id, false),
-         :ok <- FollowMailer.send_notification_to_admins(follower),
-         follower_as_data <- Convertible.model_to_as(follower),
-         {:ok, activity} <- create_activity(follower_as_data, local),
+         {:ok, activity_data, %Follower{} = follower} <-
+           Types.Actors.follow(
+             follower,
+             followed,
+             local,
+             Map.merge(additional, %{"activity_id" => activity_id})
+           ),
+         {:ok, activity} <- create_activity(activity_data, local),
          :ok <- maybe_federate(activity) do
       {:ok, activity, follower}
     else

lib/federation/activity_pub/transmogrifier.ex

@@ -302,6 +302,10 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
               do_handle_incoming_accept_join(accepted_object, actor)} do
       {:ok, activity, object}
     else
+      {:object_not_found, {:error, "Follow already accepted"}} ->
+        Logger.info("Follow was already accepted. Ignoring.")
+        :error
+
       {:object_not_found, nil} ->
         Logger.warn(
           "Unable to process Accept activity #{inspect(id)}. Object #{inspect(accepted_object)} wasn't found."
@@ -761,6 +765,10 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
 
       {:ok, activity, follow}
     else
+      {:follow, {:ok, %Follower{approved: true} = _follow}} ->
+        Logger.debug("Follow already accepted")
+        {:error, "Follow already accepted"}
+
       {:follow, _} ->
         Logger.debug(
           "Tried to handle an Accept activity but it's not containing a Follow activity"
@@ -770,9 +778,6 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
 
       {:same_actor} ->
         {:error, "Actor who accepted the follow wasn't the target. Quite odd."}
-
-      {:ok, %Follower{approved: true} = _follow} ->
-        {:error, "Follow already accepted"}
     end
   end
 

lib/federation/activity_pub/types/actors.ex

@@ -1,7 +1,7 @@
 defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   @moduledoc false
   alias Mobilizon.Actors
-  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Actors.{Actor, Follower, Member}
   alias Mobilizon.Federation.ActivityPub
   alias Mobilizon.Federation.ActivityPub.Audience
   alias Mobilizon.Federation.ActivityPub.Types.Entity
@@ -9,6 +9,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
   alias Mobilizon.Service.Formatter.HTML
   alias Mobilizon.Service.Notifications.Scheduler
+  alias Mobilizon.Web.Email.Follow, as: FollowMailer
   alias Mobilizon.Web.Endpoint
   import Mobilizon.Federation.ActivityPub.Utils, only: [make_create_data: 2, make_update_data: 2]
 
@@ -130,6 +131,15 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
     end
   end
 
+  def follow(%Actor{} = follower_actor, %Actor{} = followed, _local, additional) do
+    with {:ok, %Follower{} = follower} <-
+           Mobilizon.Actors.follow(followed, follower_actor, additional["activity_id"], false),
+         :ok <- FollowMailer.send_notification_to_admins(follower),
+         follower_as_data <- Convertible.model_to_as(follower) do
+      approve_if_manually_approves_followers(follower, follower_as_data)
+    end
+  end
+
   defp prepare_args_for_actor(args) do
     args
     |> maybe_sanitize_username()
@@ -189,4 +199,21 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
       {:ok, activity_data, member}
     end
   end
+
+  defp approve_if_manually_approves_followers(
+         %Follower{} = follower,
+         follow_as_data
+       ) do
+    unless follower.target_actor.manually_approves_followers do
+      {:accept,
+       ActivityPub.accept(
+         :follow,
+         follower,
+         true,
+         %{"actor" => follower.actor.url}
+       )}
+    end
+
+    {:ok, follow_as_data, follower}
+  end
 end

lib/graphql/resolvers/followers.ex

@@ -0,0 +1,64 @@
+defmodule Mobilizon.GraphQL.Resolvers.Followers do
+  @moduledoc """
+  Handles the followers-related GraphQL calls.
+  """
+
+  import Mobilizon.Users.Guards
+  alias Mobilizon.{Actors, Users}
+  alias Mobilizon.Actors.{Actor, Follower}
+  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Storage.Page
+  alias Mobilizon.Users.User
+
+  @spec find_followers_for_group(Actor.t(), map(), map()) :: {:ok, Page.t()}
+  def find_followers_for_group(
+        %Actor{id: group_id} = group,
+        %{page: page, limit: limit} = args,
+        %{
+          context: %{
+            current_user: %User{role: user_role} = user
+          }
+        }
+      ) do
+    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
+         {:member, true} <-
+           {:member, Actors.is_moderator?(actor_id, group_id) or is_moderator(user_role)} do
+      {:ok,
+       Actors.list_paginated_followers_for_actor(group, Map.get(args, :approved), page, limit)}
+    else
+      _ -> {:error, :unauthorized}
+    end
+  end
+
+  def find_followers_for_group(_, _, _), do: {:error, :unauthenticated}
+
+  @spec update_follower(any(), map(), map()) :: {:ok, Follower.t()} | {:error, any()}
+  def update_follower(_, %{id: follower_id, approved: approved}, %{
+        context: %{
+          current_user: %User{} = user
+        }
+      }) do
+    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
+         %Follower{target_actor: %Actor{type: :Group, id: group_id}} = follower <-
+           Actors.get_follower(follower_id),
+         {:member, true} <-
+           {:member, Actors.is_moderator?(actor_id, group_id)},
+         {:ok, _activity, %Follower{} = follower} <-
+           (if approved do
+              ActivityPub.accept(:follow, follower)
+            else
+              ActivityPub.reject(:follow, follower)
+            end) do
+      {:ok, follower}
+    else
+      {:member, _} ->
+        {:error, :unauthorized}
+
+      _ ->
+        {:error,
+         if(approved, do: "Unable to approve follower", else: "Unable to reject follower")}
+    end
+  end
+
+  def update_follower(_, _, _), do: {:error, :unauthenticated}
+end

lib/graphql/resolvers/group.ex

@@ -26,8 +26,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
           }
         }
       ) do
-    with {:ok, %Actor{id: group_id} = group} <-
-           ActivityPub.find_or_make_group_from_nickname(name),
+    with {:group, {:ok, %Actor{id: group_id} = group}} <-
+           {:group, ActivityPub.find_or_make_group_from_nickname(name)},
          {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)} do
       {:ok, group}
@@ -35,8 +35,11 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
       {:member, false} ->
         find_group(parent, args, nil)
 
-      _ ->
+      {:group, _} ->
         {:error, :group_not_found}
+
+      _ ->
+        {:error, :unknown}
     end
   end
 

lib/graphql/schema.ex

@@ -177,6 +177,7 @@ defmodule Mobilizon.GraphQL.Schema do
     import_fields(:resource_mutations)
     import_fields(:post_mutations)
     import_fields(:actor_mutations)
+    import_fields(:follower_mutations)
   end
 
   @desc """

lib/graphql/schema/actor.ex

@@ -32,8 +32,6 @@ defmodule Mobilizon.GraphQL.Schema.ActorInterface do
     field(:banner, :media, description: "The actor's banner media")
 
     # These one should have a privacy setting
-    field(:following, list_of(:follower), description: "List of followings")
-    field(:followers, list_of(:follower), description: "List of followers")
     field(:followersCount, :integer, description: "Number of followers for this actor")
     field(:followingCount, :integer, description: "Number of actors following this actor")
 

lib/graphql/schema/actors/application.ex

@@ -31,8 +31,6 @@ defmodule Mobilizon.GraphQL.Schema.Actors.ApplicationType do
     field(:banner, :media, description: "The actor's banner media")
 
     # These one should have a privacy setting
-    field(:following, list_of(:follower), description: "List of followings")
-    field(:followers, list_of(:follower), description: "List of followers")
     field(:followersCount, :integer, description: "Number of followers for this actor")
     field(:followingCount, :integer, description: "Number of actors following this actor")
 

lib/graphql/schema/actors/follower.ex

@@ -3,11 +3,13 @@ defmodule Mobilizon.GraphQL.Schema.Actors.FollowerType do
   Schema representation for Follower
   """
   use Absinthe.Schema.Notation
+  alias Mobilizon.GraphQL.Resolvers.Followers
 
   @desc """
   Represents an actor's follower
   """
   object :follower do
+    field(:id, :id, description: "The follow ID")
     field(:target_actor, :actor, description: "What or who the profile follows")
     field(:actor, :actor, description: "Which profile follows")
 
@@ -26,4 +28,17 @@ defmodule Mobilizon.GraphQL.Schema.Actors.FollowerType do
     field(:elements, list_of(:follower), description: "A list of followers")
     field(:total, :integer, description: "The total number of elements in the list")
   end
+
+  object :follower_mutations do
+    @desc "Update follower"
+    field :update_follower, :follower do
+      arg(:id, non_null(:id), description: "The follower ID")
+
+      arg(:approved, non_null(:boolean),
+        description: "Whether the follower has been approved by the target actor or not"
+      )
+
+      resolve(&Followers.update_follower/3)
+    end
+  end
 end

lib/graphql/schema/actors/group.ex

@@ -8,7 +8,18 @@ defmodule Mobilizon.GraphQL.Schema.Actors.GroupType do
   import Absinthe.Resolution.Helpers, only: [dataloader: 1]
 
   alias Mobilizon.Addresses
-  alias Mobilizon.GraphQL.Resolvers.{Discussion, Group, Media, Member, Post, Resource, Todos}
+
+  alias Mobilizon.GraphQL.Resolvers.{
+    Discussion,
+    Followers,
+    Group,
+    Media,
+    Member,
+    Post,
+    Resource,
+    Todos
+  }
+
   alias Mobilizon.GraphQL.Schema
 
   import_types(Schema.Actors.MemberType)
@@ -47,8 +58,6 @@ defmodule Mobilizon.GraphQL.Schema.Actors.GroupType do
     )
 
     # These one should have a privacy setting
-    field(:following, list_of(:follower), description: "List of followings")
-    field(:followers, list_of(:follower), description: "List of followers")
     field(:followersCount, :integer, description: "Number of followers for this actor")
     field(:followingCount, :integer, description: "Number of actors following this actor")
 
@@ -116,6 +125,23 @@ defmodule Mobilizon.GraphQL.Schema.Actors.GroupType do
       resolve(&Todos.find_todo_lists_for_group/3)
       description("A paginated list of the todo lists this group has")
     end
+
+    field :followers, :paginated_follower_list do
+      arg(:page, :integer,
+        default_value: 1,
+        description: "The page in the paginated followers list"
+      )
+
+      arg(:limit, :integer, default_value: 10, description: "The limit of followers per page")
+
+      arg(:approved, :boolean,
+        default_value: nil,
+        description: "Used to filter the followers list by approved status"
+      )
+
+      resolve(&Followers.find_followers_for_group/3)
+      description("A paginated list of the followers this group has")
+    end
   end
 
   @desc """
@@ -232,6 +258,10 @@ defmodule Mobilizon.GraphQL.Schema.Actors.GroupType do
         description: "Whether the group can be join freely, with approval or is invite-only."
       )
 
+      arg(:manually_approves_followers, :boolean,
+        description: "Whether this group approves new followers manually"
+      )
+
       arg(:avatar, :media_input,
         description:
           "The avatar for the group, either as an object or directly the ID of an existing media"

lib/graphql/schema/actors/person.ex

@@ -44,8 +44,6 @@ defmodule Mobilizon.GraphQL.Schema.Actors.PersonType do
     field(:banner, :media, description: "The actor's banner media")
 
     # These one should have a privacy setting
-    field(:following, list_of(:follower), description: "List of followings")
-    field(:followers, list_of(:follower), description: "List of followers")
     field(:followersCount, :integer, description: "Number of followers for this actor")
     field(:followingCount, :integer, description: "Number of actors following this actor")
 

lib/mobilizon/actors/actors.ex

@@ -1022,6 +1022,16 @@ defmodule Mobilizon.Actors do
   @spec list_bots :: [Bot.t()]
   def list_bots, do: Repo.all(Bot)
 
+  @doc """
+  Gets a single follower.
+  """
+  @spec get_follower(integer | String.t()) :: Follower.t() | nil
+  def get_follower(id) do
+    Follower
+    |> Repo.get(id)
+    |> Repo.preload([:actor, :target_actor])
+  end
+
   @doc """
   Gets a single follower.
   Raises `Ecto.NoResultsError` if the follower does not exist.
@@ -1149,6 +1159,25 @@ defmodule Mobilizon.Actors do
     |> Repo.aggregate(:count)
   end
 
+  @doc """
+  Returns a paginated list of followers for an actor.
+  """
+  @spec list_paginated_followers_for_actor(Actor.t(), boolean | nil, integer | nil, integer | nil) ::
+          Page.t()
+  def list_paginated_followers_for_actor(
+        %Actor{id: actor_id},
+        approved \\ nil,
+        page \\ nil,
+        limit \\ nil
+      ) do
+    actor_id
+    |> follower_for_actor_query()
+    |> filter_followed_by_approved_status(approved)
+    |> order_by(desc: :updated_at)
+    |> preload([:actor, :target_actor])
+    |> Page.build_page(page, limit)
+  end
+
   @doc """
   Returns the list of followings for an actor.
   If actor A follows actor B and C, actor A's followings are B and C.
@@ -1688,6 +1717,13 @@ defmodule Mobilizon.Actors do
     from(a in query, where: a.preferred_username == ^name and a.domain == ^domain)
   end
 
+  @spec filter_by_name(Ecto.Query.t(), boolean | nil) :: Ecto.Query.t()
+  defp filter_followed_by_approved_status(query, nil), do: query
+
+  defp filter_followed_by_approved_status(query, approved) do
+    from(f in query, where: f.approved == ^approved)
+  end
+
   @spec preload_followers(Actor.t(), boolean) :: Actor.t()
   defp preload_followers(actor, true), do: Repo.preload(actor, [:followers])
   defp preload_followers(actor, false), do: actor