Introduce comments below events

Also add tomstones

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

lib/mobilizon_web/api/comments.ex

@@ -9,11 +9,22 @@ defmodule MobilizonWeb.API.Comments do
   @doc """
   Create a comment
 
-  Creates a comment from an actor and a status
+  Creates a comment from an actor
   """
   @spec create_comment(map()) ::
           {:ok, Activity.t(), Comment.t()} | any()
   def create_comment(args) do
     ActivityPub.create(:comment, args, true)
   end
+
+  @doc """
+  Deletes a comment
+
+  Deletes a comment from an actor
+  """
+  @spec delete_comment(Comment.t()) ::
+          {:ok, Activity.t(), Comment.t()} | any()
+  def delete_comment(%Comment{} = comment) do
+    ActivityPub.delete(comment, true)
+  end
 end

lib/mobilizon_web/api/reports.ex

@@ -5,11 +5,7 @@ defmodule MobilizonWeb.API.Reports do
 
   import Mobilizon.Service.Admin.ActionLogService
 
-  import MobilizonWeb.API.Utils
-
-  alias Mobilizon.Actors
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Events
   alias Mobilizon.Reports, as: ReportsAction
   alias Mobilizon.Reports.{Note, Report, ReportStatus}
   alias Mobilizon.Service.ActivityPub
@@ -20,44 +16,16 @@ defmodule MobilizonWeb.API.Reports do
   @doc """
   Create a report/flag on an actor, and optionally on an event or on comments.
   """
-  def report(
-        %{
-          reporter_actor_id: reporter_actor_id,
-          reported_actor_id: reported_actor_id
-        } = args
-      ) do
-    with {:reporter, %Actor{url: reporter_url} = _reporter_actor} <-
-           {:reporter, Actors.get_actor!(reporter_actor_id)},
-         {:reported, %Actor{url: reported_actor_url} = reported_actor} <-
-           {:reported, Actors.get_actor!(reported_actor_id)},
-         {:ok, content} <- args |> Map.get(:content, nil) |> make_report_content_text(),
-         {:ok, event} <- args |> Map.get(:event_id, nil) |> get_event(),
-         {:get_report_comments, comments_urls} <-
-           get_report_comments(reported_actor, Map.get(args, :comments_ids, [])),
-         {:make_activity, {:ok, %Activity{} = activity, %Report{} = report}} <-
-           {:make_activity,
-            ActivityPub.flag(%{
-              reporter_url: reporter_url,
-              reported_actor_url: reported_actor_url,
-              event_url: (!is_nil(event) && event.url) || nil,
-              comments_url: comments_urls,
-              content: content,
-              forward: args[:forward] || false,
-              local: args[:local] || args[:forward] || false
-            })} do
-      {:ok, activity, report}
-    else
-      {:make_activity, err} -> {:error, err}
-      {:error, err} -> {:error, err}
-      {:actor_id, %{}} -> {:error, "Valid `actor_id` required"}
-      {:reporter, nil} -> {:error, "Reporter Actor not found"}
-      {:reported, nil} -> {:error, "Reported Actor not found"}
+  def report(args) do
+    case {:make_activity, ActivityPub.flag(args, Map.get(args, :local, false) == false)} do
+      {:make_activity, {:ok, %Activity{} = activity, %Report{} = report}} ->
+        {:ok, activity, report}
+
+      {:make_activity, err} ->
+        {:error, err}
     end
   end
 
-  defp get_event(nil), do: {:ok, nil}
-  defp get_event(event_id), do: Events.get_event(event_id)
-
   @doc """
   Update the state of a report
   """
@@ -72,13 +40,6 @@ defmodule MobilizonWeb.API.Reports do
     end
   end
 
-  defp get_report_comments(%Actor{id: actor_id}, comment_ids) do
-    {:get_report_comments,
-     actor_id |> Events.list_comments_by_actor_and_ids(comment_ids) |> Enum.map(& &1.url)}
-  end
-
-  defp get_report_comments(_, _), do: {:get_report_comments, nil}
-
   @doc """
   Create a note on a report
   """

lib/mobilizon_web/resolvers/admin.ex

@@ -7,7 +7,7 @@ defmodule MobilizonWeb.Resolvers.Admin do
 
   alias Mobilizon.Admin.ActionLog
   alias Mobilizon.Events
-  alias Mobilizon.Events.Event
+  alias Mobilizon.Events.{Event, Comment}
   alias Mobilizon.Reports.{Note, Report}
   alias Mobilizon.Service.Statistics
   alias Mobilizon.Users.User
@@ -90,6 +90,15 @@ defmodule MobilizonWeb.Resolvers.Admin do
     }
   end
 
+  defp transform_action_log(Comment, :delete, %ActionLog{
+         changes: changes
+       }) do
+    %{
+      action: :comment_deletion,
+      object: convert_changes_to_struct(Comment, changes)
+    }
+  end
+
   # Changes are stored as %{"key" => "value"} so we need to convert them back as struct
   defp convert_changes_to_struct(struct, %{"report_id" => _report_id} = changes) do
     with data <- for({key, val} <- changes, into: %{}, do: {String.to_atom(key), val}),

lib/mobilizon_web/resolvers/comment.ex

@@ -3,25 +3,73 @@ defmodule MobilizonWeb.Resolvers.Comment do
   Handles the comment-related GraphQL calls.
   """
 
-  alias Mobilizon.Events.Comment
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Comment, as: CommentModel
   alias Mobilizon.Users.User
   alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors
 
   alias MobilizonWeb.API.Comments
+  import Mobilizon.Service.Admin.ActionLogService
 
   require Logger
 
-  def create_comment(_parent, %{text: text, actor_id: actor_id}, %{
+  def get_thread(_parent, %{id: thread_id}, _context) do
+    {:ok, Events.get_thread_replies(thread_id)}
+  end
+
+  def create_comment(_parent, %{actor_id: actor_id} = args, %{
         context: %{current_user: %User{} = user}
       }) do
     with {:is_owned, %Actor{} = _organizer_actor} <- User.owns_actor(user, actor_id),
-         {:ok, _, %Comment{} = comment} <-
-           Comments.create_comment(%{actor_id: actor_id, text: text}) do
+         {:ok, _, %CommentModel{} = comment} <-
+           Comments.create_comment(args) do
       {:ok, comment}
+    else
+      {:is_owned, nil} ->
+        {:error, "Actor id is not owned by authenticated user"}
     end
   end
 
-  def create_comment(_parent, _args, %{}) do
+  def create_comment(_parent, _args, _context) do
     {:error, "You are not allowed to create a comment if not connected"}
   end
+
+  def delete_comment(_parent, %{actor_id: actor_id, comment_id: comment_id}, %{
+        context: %{current_user: %User{role: role} = user}
+      }) do
+    with {actor_id, ""} <- Integer.parse(actor_id),
+         {:is_owned, %Actor{} = _organizer_actor} <- User.owns_actor(user, actor_id),
+         %CommentModel{} = comment <- Events.get_comment_with_preload(comment_id) do
+      cond do
+        {:comment_can_be_managed, true} == CommentModel.can_be_managed_by(comment, actor_id) ->
+          do_delete_comment(comment)
+
+        role in [:moderator, :administrator] ->
+          with {:ok, res} <- do_delete_comment(comment),
+               %Actor{} = actor <- Actors.get_actor(actor_id) do
+            log_action(actor, "delete", comment)
+
+            {:ok, res}
+          end
+
+        true ->
+          {:error, "You cannot delete this comment"}
+      end
+    else
+      {:is_owned, nil} ->
+        {:error, "Actor id is not owned by authenticated user"}
+    end
+  end
+
+  def delete_comment(_parent, _args, %{}) do
+    {:error, "You are not allowed to delete a comment if not connected"}
+  end
+
+  defp do_delete_comment(%CommentModel{} = comment) do
+    with {:ok, _, %CommentModel{} = comment} <-
+           Comments.delete_comment(comment) do
+      {:ok, comment}
+    end
+  end
 end

lib/mobilizon_web/resolvers/report.ex

@@ -46,10 +46,10 @@ defmodule MobilizonWeb.Resolvers.Report do
   """
   def create_report(
         _parent,
-        %{reporter_actor_id: reporter_actor_id} = args,
+        %{reporter_id: reporter_id} = args,
         %{context: %{current_user: user}} = _resolution
       ) do
-    with {:is_owned, %Actor{}} <- User.owns_actor(user, reporter_actor_id),
+    with {:is_owned, %Actor{}} <- User.owns_actor(user, reporter_id),
          {:ok, _, %Report{} = report} <- ReportsAPI.report(args) do
       {:ok, report}
     else

lib/mobilizon_web/router.ex

@@ -49,7 +49,11 @@ defmodule MobilizonWeb.Router do
   scope "/api" do
     pipe_through(:graphql)
 
-    forward("/", Absinthe.Plug, schema: MobilizonWeb.Schema)
+    forward("/", Absinthe.Plug,
+      schema: MobilizonWeb.Schema,
+      analyze_complexity: true,
+      max_complexity: 200
+    )
   end
 
   forward("/graphiql", Absinthe.Plug.GraphiQL, schema: MobilizonWeb.Schema)

lib/mobilizon_web/schema.ex

@@ -96,7 +96,7 @@ defmodule MobilizonWeb.Schema do
       Dataloader.new()
       |> Dataloader.add_source(Actors, default_source)
       |> Dataloader.add_source(Users, default_source)
-      |> Dataloader.add_source(Events, default_source)
+      |> Dataloader.add_source(Events, Events.data())
       |> Dataloader.add_source(Addresses, default_source)
       |> Dataloader.add_source(Media, default_source)
       |> Dataloader.add_source(Reports, default_source)
@@ -117,6 +117,7 @@ defmodule MobilizonWeb.Schema do
     import_fields(:person_queries)
     import_fields(:group_queries)
     import_fields(:event_queries)
+    import_fields(:comment_queries)
     import_fields(:tag_queries)
     import_fields(:address_queries)
     import_fields(:config_queries)

lib/mobilizon_web/schema/admin.ex

@@ -5,7 +5,7 @@ defmodule MobilizonWeb.Schema.AdminType do
 
   use Absinthe.Schema.Notation
 
-  alias Mobilizon.Events.Event
+  alias Mobilizon.Events.{Event, Comment}
   alias Mobilizon.Reports.{Note, Report}
 
   alias MobilizonWeb.Resolvers.Admin
@@ -26,6 +26,7 @@ defmodule MobilizonWeb.Schema.AdminType do
     value(:note_creation)
     value(:note_deletion)
     value(:event_deletion)
+    value(:comment_deletion)
     value(:event_update)
   end
 
@@ -43,6 +44,9 @@ defmodule MobilizonWeb.Schema.AdminType do
       %Event{}, _ ->
         :event
 
+      %Comment{}, _ ->
+        :comment
+
       _, _ ->
         nil
     end)

lib/mobilizon_web/schema/comment.ex

@@ -4,9 +4,12 @@ defmodule MobilizonWeb.Schema.CommentType do
   """
   use Absinthe.Schema.Notation
   alias MobilizonWeb.Resolvers.Comment
+  alias Mobilizon.{Actors, Events}
+  import Absinthe.Resolution.Helpers, only: [dataloader: 1]
 
   @desc "A comment"
   object :comment do
+    interfaces([:action_log_object])
     field(:id, :id, description: "Internal ID for this comment")
     field(:uuid, :uuid)
     field(:url, :string)
@@ -14,8 +17,20 @@ defmodule MobilizonWeb.Schema.CommentType do
     field(:visibility, :comment_visibility)
     field(:text, :string)
     field(:primaryLanguage, :string)
-    field(:replies, list_of(:comment))
+
+    field(:replies, list_of(:comment)) do
+      resolve(dataloader(Events))
+    end
+
+    field(:total_replies, :integer)
+    field(:in_reply_to_comment, :comment, resolve: dataloader(Events))
+    field(:event, :event, resolve: dataloader(Events))
+    field(:origin_comment, :comment, resolve: dataloader(Events))
     field(:threadLanguages, non_null(list_of(:string)))
+    field(:actor, :person, resolve: dataloader(Actors))
+    field(:inserted_at, :datetime)
+    field(:updated_at, :datetime)
+    field(:deleted_at, :datetime)
   end
 
   @desc "The list of visibility options for a comment"
@@ -31,13 +46,30 @@ defmodule MobilizonWeb.Schema.CommentType do
     value(:invite, description: "visible only to people invited")
   end
 
+  object :comment_queries do
+    @desc "Get replies for thread"
+    field :thread, type: list_of(:comment) do
+      arg(:id, :id)
+      resolve(&Comment.get_thread/3)
+    end
+  end
+
   object :comment_mutations do
     @desc "Create a comment"
     field :create_comment, type: :comment do
       arg(:text, non_null(:string))
+      arg(:event_id, :id)
+      arg(:in_reply_to_comment_id, :id)
       arg(:actor_id, non_null(:id))
 
       resolve(&Comment.create_comment/3)
     end
+
+    field :delete_comment, type: :comment do
+      arg(:comment_id, non_null(:id))
+      arg(:actor_id, non_null(:id))
+
+      resolve(&Comment.delete_comment/3)
+    end
   end
 end

lib/mobilizon_web/schema/event.ex

@@ -8,7 +8,7 @@ defmodule MobilizonWeb.Schema.EventType do
   import Absinthe.Resolution.Helpers, only: [dataloader: 1]
   import MobilizonWeb.Schema.Utils
 
-  alias Mobilizon.{Actors, Addresses}
+  alias Mobilizon.{Actors, Addresses, Events}
 
   alias MobilizonWeb.Resolvers.{Event, Picture, Tag}
 
@@ -78,6 +78,10 @@ defmodule MobilizonWeb.Schema.EventType do
       description: "Events related to this one"
     )
 
+    field(:comments, list_of(:comment), description: "The comments in reply to the event") do
+      resolve(dataloader(Events))
+    end
+
     # field(:tracks, list_of(:track))
     # field(:sessions, list_of(:session))
 

lib/mobilizon_web/schema/report.ex

@@ -71,8 +71,8 @@ defmodule MobilizonWeb.Schema.ReportType do
     @desc "Create a report"
     field :create_report, type: :report do
       arg(:content, :string)
-      arg(:reporter_actor_id, non_null(:id))
-      arg(:reported_actor_id, non_null(:id))
+      arg(:reporter_id, non_null(:id))
+      arg(:reported_id, non_null(:id))
       arg(:event_id, :id, default_value: nil)
       arg(:comments_ids, list_of(:id), default_value: [])
       resolve(&Report.create_report/3)