Add GraphQL support to handle FeedTokens

Closes #88

Automatically create tokens for new users and actors

Closes #89

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

lib/mobilizon/actors/actors.ex

@@ -9,7 +9,6 @@ defmodule Mobilizon.Actors do
   alias Mobilizon.Repo
 
   alias Mobilizon.Actors.{Actor, Bot, Member, Follower}
-  alias Mobilizon.Users.User
 
   alias Mobilizon.Service.ActivityPub
   # import Exgravatar
@@ -505,17 +504,6 @@ defmodule Mobilizon.Actors do
     [entry] |> :public_key.pem_encode() |> String.trim_trailing()
   end
 
-  @doc """
-  Register user
-  """
-  @spec register(map()) :: {:ok, User.t()} | {:error, String.t()}
-  def register(%{email: _email, password: _password} = args) do
-    with {:ok, %User{} = user} <-
-           %User{} |> User.registration_changeset(args) |> Mobilizon.Repo.insert() do
-      {:ok, user}
-    end
-  end
-
   @doc """
   Create a new person actor
   """
@@ -525,8 +513,13 @@ defmodule Mobilizon.Actors do
     pem = [entry] |> :public_key.pem_encode() |> String.trim_trailing()
     args = Map.put(args, :keys, pem)
 
-    actor = Mobilizon.Actors.Actor.registration_changeset(%Mobilizon.Actors.Actor{}, args)
-    Mobilizon.Repo.insert(actor)
+    with {:ok, %Actor{} = person} <-
+           %Actor{}
+           |> Actor.registration_changeset(args)
+           |> Repo.insert() do
+      Mobilizon.Events.create_feed_token(%{"user_id" => args["user_id"], "actor_id" => person.id})
+      {:ok, person}
+    end
   end
 
   def register_bot_account(%{name: name, summary: summary}) do

lib/mobilizon/events/events.ex

@@ -9,6 +9,7 @@ defmodule Mobilizon.Events do
   alias Mobilizon.Repo
   alias Mobilizon.Events.{Event, Comment, Participant}
   alias Mobilizon.Actors.Actor
+  alias Mobilizon.Users.User
   alias Mobilizon.Addresses.Address
 
   def data() do
@@ -1192,6 +1193,32 @@ defmodule Mobilizon.Events do
     |> Repo.one!()
   end
 
+  @doc """
+  Get feed tokens for an user
+  """
+  @spec get_feed_tokens(User.t()) :: list(FeedTokens.t())
+  def get_feed_tokens(%User{id: id}) do
+    from(
+      tk in FeedToken,
+      where: tk.user_id == ^id,
+      preload: [:actor, :user]
+    )
+    |> Repo.all()
+  end
+
+  @doc """
+  Get feed tokens for an actor
+  """
+  @spec get_feed_tokens(Actor.t()) :: list(FeedTokens.t())
+  def get_feed_tokens(%Actor{id: id, domain: nil}) do
+    from(
+      tk in FeedToken,
+      where: tk.actor_id == ^id,
+      preload: [:actor, :user]
+    )
+    |> Repo.all()
+  end
+
   @doc """
   Creates a feed token.
 
@@ -1205,6 +1232,8 @@ defmodule Mobilizon.Events do
 
   """
   def create_feed_token(attrs \\ %{}) do
+    attrs = Map.put(attrs, "token", Ecto.UUID.generate())
+
     %FeedToken{}
     |> FeedToken.changeset(attrs)
     |> Repo.insert()

lib/mobilizon/events/feed_token.ex

@@ -9,8 +9,8 @@ defmodule Mobilizon.Events.FeedToken do
   alias Mobilizon.Users.User
 
   @primary_key false
-  schema "feed_token" do
-    field(:token, :string, primary_key: true)
+  schema "feed_tokens" do
+    field(:token, Ecto.UUID, primary_key: true)
     belongs_to(:actor, Actor)
     belongs_to(:user, User)
 

lib/mobilizon/users/users.ex

@@ -21,6 +21,18 @@ defmodule Mobilizon.Users do
     queryable
   end
 
+  @doc """
+  Register user
+  """
+  @spec register(map()) :: {:ok, User.t()} | {:error, String.t()}
+  def register(%{email: _email, password: _password} = args) do
+    with {:ok, %User{} = user} <-
+           %User{} |> User.registration_changeset(args) |> Mobilizon.Repo.insert() do
+      Mobilizon.Events.create_feed_token(%{"user_id" => user.id})
+      {:ok, user}
+    end
+  end
+
   @doc """
   Gets an user by it's email
 

lib/mobilizon_web/resolvers/feed_token.ex

@@ -0,0 +1,77 @@
+defmodule MobilizonWeb.Resolvers.FeedToken do
+  @moduledoc """
+  Handles the feed tokens-related GraphQL calls
+  """
+  require Logger
+  alias Mobilizon.Users.User
+  alias Mobilizon.Events
+  alias Mobilizon.Events.FeedToken
+
+  @doc """
+  Create an feed token for an user and a defined actor
+  """
+  @spec create_feed_token(any(), map(), map()) :: {:ok, FeedToken.t()} | {:error, String.t()}
+  def create_feed_token(_parent, %{actor_id: actor_id}, %{
+        context: %{current_user: %User{id: id} = user}
+      }) do
+    with {:is_owned, true, _actor} <- User.owns_actor(user, actor_id),
+         {:ok, feed_token} <- Events.create_feed_token(%{"user_id" => id, "actor_id" => actor_id}) do
+      {:ok, feed_token}
+    else
+      {:is_owned, false} ->
+        {:error, "Actor id is not owned by authenticated user"}
+    end
+  end
+
+  @doc """
+  Create an feed token for an user
+  """
+  @spec create_feed_token(any(), map(), map()) :: {:ok, FeedToken.t()}
+  def create_feed_token(_parent, %{}, %{
+        context: %{current_user: %User{id: id}}
+      }) do
+    with {:ok, feed_token} <- Events.create_feed_token(%{"user_id" => id}) do
+      {:ok, feed_token}
+    end
+  end
+
+  @spec create_feed_token(any(), map(), map()) :: {:error, String.t()}
+  def create_feed_token(_parent, _args, %{}) do
+    {:error, "You are not allowed to create a feed token if not connected"}
+  end
+
+  @doc """
+  Delete a feed token
+  """
+  @spec delete_feed_token(any(), map(), map()) :: {:ok, map()} | {:error, String.t()}
+  def delete_feed_token(_parent, %{token: token}, %{
+        context: %{current_user: %User{id: id} = _user}
+      }) do
+    with {:ok, token} <- Ecto.UUID.cast(token),
+         {:no_token, %FeedToken{actor: actor, user: %User{} = user} = feed_token} <-
+           {:no_token, Events.get_feed_token(token)},
+         {:token_from_user, true} <- {:token_from_user, id == user.id},
+         {:ok, _} <- Events.delete_feed_token(feed_token) do
+      res = %{user: %{id: id}}
+      res = if is_nil(actor), do: res, else: Map.put(res, :actor, %{id: actor.id})
+      {:ok, res}
+    else
+      {:error, nil} ->
+        {:error, "No such feed token"}
+
+      :error ->
+        {:error, "Token is not a valid UUID"}
+
+      {:no_token, _} ->
+        {:error, "Token does not exist"}
+
+      {:token_from_user, false} ->
+        {:error, "You don't have permission to delete this token"}
+    end
+  end
+
+  @spec delete_feed_token(any(), map(), map()) :: {:error, String.t()}
+  def delete_feed_token(_parent, _args, %{}) do
+    {:error, "You are not allowed to delete a feed token if not connected"}
+  end
+end

lib/mobilizon_web/resolvers/user.ex

@@ -70,7 +70,7 @@ defmodule MobilizonWeb.Resolvers.User do
   """
   @spec create_user(any(), map(), any()) :: tuple()
   def create_user(_parent, args, _resolution) do
-    with {:ok, %User{} = user} <- Actors.register(args) do
+    with {:ok, %User{} = user} <- Users.register(args) do
       Activation.send_confirmation_email(user)
       {:ok, user}
     end

lib/mobilizon_web/schema.ex

@@ -4,7 +4,7 @@ defmodule MobilizonWeb.Schema do
   """
   use Absinthe.Schema
 
-  alias Mobilizon.{Actors, Events}
+  alias Mobilizon.{Actors, Events, Users}
   alias Mobilizon.Actors.{Actor, Follower, Member}
   alias Mobilizon.Events.{Event, Comment, Participant}
 
@@ -104,6 +104,7 @@ defmodule MobilizonWeb.Schema do
     loader =
       Dataloader.new()
       |> Dataloader.add_source(Actors, Actors.data())
+      |> Dataloader.add_source(Users, Users.data())
       |> Dataloader.add_source(Events, Events.data())
 
     Map.put(ctx, :loader, loader)
@@ -144,6 +145,7 @@ defmodule MobilizonWeb.Schema do
     import_fields(:comment_mutations)
     import_fields(:participant_mutations)
     import_fields(:member_mutations)
+    import_fields(:feed_token_mutations)
 
     # @desc "Upload a picture"
     # field :upload_picture, :picture do

lib/mobilizon_web/schema/actors/person.ex

@@ -8,6 +8,8 @@ defmodule MobilizonWeb.Schema.Actors.PersonType do
   alias MobilizonWeb.Resolvers
   import MobilizonWeb.Schema.Utils
 
+  import_types(MobilizonWeb.Schema.Events.FeedTokenType)
+
   @desc """
   Represents a person identity
   """
@@ -41,6 +43,11 @@ defmodule MobilizonWeb.Schema.Actors.PersonType do
     field(:followersCount, :integer, description: "Number of followers for this actor")
     field(:followingCount, :integer, description: "Number of actors following this actor")
 
+    field(:feed_tokens, list_of(:feed_token),
+      resolve: dataloader(Events),
+      description: "A list of the feed tokens for this person"
+    )
+
     # This one should have a privacy setting
     field(:organized_events, list_of(:event),
       resolve: dataloader(Events),

lib/mobilizon_web/schema/events/feed_token.ex

@@ -0,0 +1,51 @@
+defmodule MobilizonWeb.Schema.Events.FeedTokenType do
+  @moduledoc """
+  Schema representation for Participant
+  """
+  use Absinthe.Schema.Notation
+  import Absinthe.Resolution.Helpers, only: [dataloader: 1]
+  alias MobilizonWeb.Resolvers
+  alias Mobilizon.Users
+  alias Mobilizon.Actors
+
+  @desc "Represents a participant to an event"
+  object :feed_token do
+    field(
+      :actor,
+      :actor,
+      resolve: dataloader(Actors),
+      description: "The event which the actor participates in"
+    )
+
+    field(
+      :user,
+      :user,
+      resolve: dataloader(Users),
+      description: "The actor that participates to the event"
+    )
+
+    field(:token, :string, description: "The role of this actor at this event")
+  end
+
+  @desc "Represents a deleted feed_token"
+  object :deleted_feed_token do
+    field(:user, :deleted_object)
+    field(:actor, :deleted_object)
+  end
+
+  object :feed_token_mutations do
+    @desc "Create a Feed Token"
+    field :create_feed_token, :feed_token do
+      arg(:actor_id, :integer)
+
+      resolve(&Resolvers.FeedToken.create_feed_token/3)
+    end
+
+    @desc "Delete a feed token"
+    field :delete_feed_token, :deleted_feed_token do
+      arg(:token, non_null(:string))
+
+      resolve(&Resolvers.FeedToken.delete_feed_token/3)
+    end
+  end
+end

lib/mobilizon_web/schema/user.ex

@@ -3,6 +3,8 @@ defmodule MobilizonWeb.Schema.UserType do
   Schema representation for User
   """
   use Absinthe.Schema.Notation
+  import Absinthe.Resolution.Helpers, only: [dataloader: 1]
+  alias Mobilizon.Events
   alias MobilizonWeb.Resolvers.User
   import MobilizonWeb.Schema.Utils
 
@@ -36,6 +38,11 @@ defmodule MobilizonWeb.Schema.UserType do
     field(:reset_password_token, :string,
       description: "The token sent when requesting password token"
     )
+
+    field(:feed_tokens, list_of(:feed_token),
+      resolve: dataloader(Events),
+      description: "A list of the feed tokens for this user"
+    )
   end
 
   @desc "Users list"