git.squeep.com Git - akkoma/blob - lib/mix/tasks/pleroma/diagnostics.ex

   1 # credo:disable-for-this-file
   2 defmodule Mix.Tasks.Pleroma.Diagnostics do
   3   alias Pleroma.Repo
   4   alias Pleroma.User
   5
   6   require Logger
   7   require Pleroma.Constants
   8
   9   import Mix.Pleroma
  10   import Ecto.Query
  11   use Mix.Task
  12
  13   def run(["http", url]) do
  14     start_pleroma()
  15
  16     Pleroma.HTTP.get(url)
  17     |> IO.inspect()
  18   end
  19
  20   def run(["home_timeline", nickname]) do
  21     start_pleroma()
  22     user = Repo.get_by!(User, nickname: nickname)
  23     Logger.info("Home timeline query #{user.nickname}")
  24
  25     followed_hashtags =
  26       user
  27       |> User.followed_hashtags()
  28       |> Enum.map(& &1.id)
  29
  30     params =
  31       %{limit: 20}
  32       |> Map.put(:type, ["Create", "Announce"])
  33       |> Map.put(:blocking_user, user)
  34       |> Map.put(:muting_user, user)
  35       |> Map.put(:reply_filtering_user, user)
  36       |> Map.put(:announce_filtering_user, user)
  37       |> Map.put(:user, user)
  38       |> Map.put(:followed_hashtags, followed_hashtags)
  39       |> Map.delete(:local)
  40
  41     list_memberships = Pleroma.List.memberships(user)
  42     recipients = [user.ap_id | User.following(user)]
  43
  44     query =
  45       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query(
  46         recipients ++ list_memberships,
  47         params
  48       )
  49       |> limit(20)
  50
  51     Ecto.Adapters.SQL.explain(Repo, :all, query, analyze: true, timeout: :infinity)
  52     |> IO.puts()
  53   end
  54
  55   def run(["user_timeline", nickname, reading_nickname]) do
  56     start_pleroma()
  57     user = Repo.get_by!(User, nickname: nickname)
  58     reading_user = Repo.get_by!(User, nickname: reading_nickname)
  59     Logger.info("User timeline query #{user.nickname}")
  60
  61     params =
  62       %{limit: 20}
  63       |> Map.put(:type, ["Create", "Announce"])
  64       |> Map.put(:user, reading_user)
  65       |> Map.put(:actor_id, user.ap_id)
  66       |> Map.put(:pinned_object_ids, Map.keys(user.pinned_objects))
  67
  68     list_memberships = Pleroma.List.memberships(user)
  69
  70     recipients =
  71       %{
  72         godmode: params[:godmode],
  73         reading_user: reading_user
  74       }
  75       |> Pleroma.Web.ActivityPub.ActivityPub.user_activities_recipients()
  76
  77     query =
  78       (recipients ++ list_memberships)
  79       |> Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query(params)
  80       |> limit(20)
  81
  82     Ecto.Adapters.SQL.explain(Repo, :all, query, analyze: true, timeout: :infinity)
  83     |> IO.puts()
  84   end
  85
  86   def run(["notifications", nickname]) do
  87     start_pleroma()
  88     user = Repo.get_by!(User, nickname: nickname)
  89     account_ap_id = user.ap_id
  90     options = %{account_ap_id: user.ap_id}
  91
  92     query =
  93       user
  94       |> Pleroma.Notification.for_user_query(options)
  95       |> where([n, a], a.actor == ^account_ap_id)
  96       |> limit(20)
  97
  98     Ecto.Adapters.SQL.explain(Repo, :all, query, analyze: true, timeout: :infinity)
  99     |> IO.puts()
 100   end
 101
 102   def run(["known_network", nickname]) do
 103     start_pleroma()
 104     user = Repo.get_by!(User, nickname: nickname)
 105
 106     params =
 107       %{}
 108       |> Map.put(:type, ["Create"])
 109       |> Map.put(:local_only, false)
 110       |> Map.put(:blocking_user, user)
 111       |> Map.put(:muting_user, user)
 112       |> Map.put(:reply_filtering_user, user)
 113       # Restricts unfederated content to authenticated users
 114       |> Map.put(:includes_local_public, not is_nil(user))
 115       |> Map.put(:restrict_unlisted, true)
 116
 117     query =
 118       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query(
 119         [Pleroma.Constants.as_public()],
 120         params
 121       )
 122       |> limit(20)
 123
 124     Ecto.Adapters.SQL.explain(Repo, :all, query, analyze: true, timeout: :infinity)
 125     |> IO.puts()
 126   end
 127 end