git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/views/account_view.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.AccountView do
   6   use Pleroma.Web, :view
   7
   8   alias Pleroma.User
   9   alias Pleroma.Web.CommonAPI.Utils
  10   alias Pleroma.Web.MastodonAPI.AccountView
  11   alias Pleroma.Web.MediaProxy
  12
  13   def test_rel(user_relationships, rel_type, source, target, func) do
  14     cond do
  15       is_nil(source) or is_nil(target) ->
  16         false
  17
  18       user_relationships ->
  19         [rel_type, source.id, target.id] in user_relationships
  20
  21       true ->
  22         func.(source, target)
  23     end
  24   end
  25
  26   def render("index.json", %{users: users} = opts) do
  27     users
  28     |> render_many(AccountView, "show.json", opts)
  29     |> Enum.filter(&Enum.any?/1)
  30   end
  31
  32   def render("show.json", %{user: user} = opts) do
  33     if User.visible_for?(user, opts[:for]),
  34       do: do_render("show.json", opts),
  35       else: %{}
  36   end
  37
  38   def render("mention.json", %{user: user}) do
  39     %{
  40       id: to_string(user.id),
  41       acct: user.nickname,
  42       username: username_from_nickname(user.nickname),
  43       url: User.profile_url(user)
  44     }
  45   end
  46
  47   def render("relationship.json", %{user: nil, target: _target}) do
  48     %{}
  49   end
  50
  51   def render(
  52         "relationship.json",
  53         %{user: %User{} = reading_user, target: %User{} = target} = opts
  54       ) do
  55     user_relationships = Map.get(opts, :user_relationships)
  56
  57     follow_state = User.get_follow_state(reading_user, target)
  58
  59     # TODO: add a note on adjusting StatusView.user_relationships_opt/1 re: preloading of user relations
  60     %{
  61       id: to_string(target.id),
  62       following: follow_state == "accept",
  63       followed_by: User.following?(target, reading_user),
  64       blocking:
  65         test_rel(user_relationships, :block, reading_user, target, &User.blocks_user?(&1, &2)),
  66       blocked_by:
  67         test_rel(user_relationships, :block, target, reading_user, &User.blocks_user?(&1, &2)),
  68       muting: test_rel(user_relationships, :mute, reading_user, target, &User.mutes?(&1, &2)),
  69       muting_notifications:
  70         test_rel(
  71           user_relationships,
  72           :notification_mute,
  73           reading_user,
  74           target,
  75           &User.muted_notifications?(&1, &2)
  76         ),
  77       subscribing:
  78         test_rel(
  79           user_relationships,
  80           :inverse_subscription,
  81           target,
  82           reading_user,
  83           &User.subscribed_to?(&2, &1)
  84         ),
  85       requested: follow_state == "pending",
  86       domain_blocking: User.blocks_domain?(reading_user, target),
  87       showing_reblogs:
  88         not test_rel(
  89           user_relationships,
  90           :reblog_mute,
  91           reading_user,
  92           target,
  93           &User.muting_reblogs?(&1, &2)
  94         ),
  95       endorsed: false
  96     }
  97   end
  98
  99   def render("relationships.json", %{user: user, targets: targets}) do
 100     render_many(targets, AccountView, "relationship.json", user: user, as: :target)
 101   end
 102
 103   defp do_render("show.json", %{user: user} = opts) do
 104     user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
 105     display_name = user.name || user.nickname
 106
 107     image = User.avatar_url(user) |> MediaProxy.url()
 108     header = User.banner_url(user) |> MediaProxy.url()
 109
 110     following_count =
 111       if !user.hide_follows_count or !user.hide_follows or opts[:for] == user do
 112         user.following_count || 0
 113       else
 114         0
 115       end
 116
 117     followers_count =
 118       if !user.hide_followers_count or !user.hide_followers or opts[:for] == user do
 119         user.follower_count || 0
 120       else
 121         0
 122       end
 123
 124     bot = user.actor_type in ["Application", "Service"]
 125
 126     emojis =
 127       (user.source_data["tag"] || [])
 128       |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
 129       |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
 130         %{
 131           "shortcode" => String.trim(name, ":"),
 132           "url" => MediaProxy.url(url),
 133           "static_url" => MediaProxy.url(url),
 134           "visible_in_picker" => false
 135         }
 136       end)
 137
 138     relationship =
 139       render("relationship.json", %{
 140         user: opts[:for],
 141         target: user,
 142         user_relationships: opts[:user_relationships]
 143       })
 144
 145     %{
 146       id: to_string(user.id),
 147       username: username_from_nickname(user.nickname),
 148       acct: user.nickname,
 149       display_name: display_name,
 150       locked: user.locked,
 151       created_at: Utils.to_masto_date(user.inserted_at),
 152       followers_count: followers_count,
 153       following_count: following_count,
 154       statuses_count: user.note_count,
 155       note: user.bio || "",
 156       url: User.profile_url(user),
 157       avatar: image,
 158       avatar_static: image,
 159       header: header,
 160       header_static: header,
 161       emojis: emojis,
 162       fields: user.fields,
 163       bot: bot,
 164       source: %{
 165         note: Pleroma.HTML.strip_tags((user.bio || "") |> String.replace("<br>", "\n")),
 166         sensitive: false,
 167         fields: user.raw_fields,
 168         pleroma: %{
 169           discoverable: user.discoverable,
 170           actor_type: user.actor_type
 171         }
 172       },
 173
 174       # Pleroma extension
 175       pleroma: %{
 176         confirmation_pending: user.confirmation_pending,
 177         tags: user.tags,
 178         hide_followers_count: user.hide_followers_count,
 179         hide_follows_count: user.hide_follows_count,
 180         hide_followers: user.hide_followers,
 181         hide_follows: user.hide_follows,
 182         hide_favorites: user.hide_favorites,
 183         relationship: relationship,
 184         skip_thread_containment: user.skip_thread_containment,
 185         background_image: image_url(user.background) |> MediaProxy.url()
 186       }
 187     }
 188     |> maybe_put_role(user, opts[:for])
 189     |> maybe_put_settings(user, opts[:for], opts)
 190     |> maybe_put_notification_settings(user, opts[:for])
 191     |> maybe_put_settings_store(user, opts[:for], opts)
 192     |> maybe_put_chat_token(user, opts[:for], opts)
 193     |> maybe_put_activation_status(user, opts[:for])
 194     |> maybe_put_follow_requests_count(user, opts[:for])
 195     |> maybe_put_allow_following_move(user, opts[:for])
 196     |> maybe_put_unread_conversation_count(user, opts[:for])
 197   end
 198
 199   defp username_from_nickname(string) when is_binary(string) do
 200     hd(String.split(string, "@"))
 201   end
 202
 203   defp username_from_nickname(_), do: nil
 204
 205   defp maybe_put_follow_requests_count(
 206          data,
 207          %User{id: user_id} = user,
 208          %User{id: user_id}
 209        ) do
 210     count =
 211       User.get_follow_requests(user)
 212       |> length()
 213
 214     data
 215     |> Kernel.put_in([:follow_requests_count], count)
 216   end
 217
 218   defp maybe_put_follow_requests_count(data, _, _), do: data
 219
 220   defp maybe_put_settings(
 221          data,
 222          %User{id: user_id} = user,
 223          %User{id: user_id},
 224          _opts
 225        ) do
 226     data
 227     |> Kernel.put_in([:source, :privacy], user.default_scope)
 228     |> Kernel.put_in([:source, :pleroma, :show_role], user.show_role)
 229     |> Kernel.put_in([:source, :pleroma, :no_rich_text], user.no_rich_text)
 230   end
 231
 232   defp maybe_put_settings(data, _, _, _), do: data
 233
 234   defp maybe_put_settings_store(data, %User{} = user, %User{}, %{
 235          with_pleroma_settings: true
 236        }) do
 237     data
 238     |> Kernel.put_in([:pleroma, :settings_store], user.pleroma_settings_store)
 239   end
 240
 241   defp maybe_put_settings_store(data, _, _, _), do: data
 242
 243   defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
 244          with_chat_token: token
 245        }) do
 246     data
 247     |> Kernel.put_in([:pleroma, :chat_token], token)
 248   end
 249
 250   defp maybe_put_chat_token(data, _, _, _), do: data
 251
 252   defp maybe_put_role(data, %User{show_role: true} = user, _) do
 253     data
 254     |> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
 255     |> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
 256   end
 257
 258   defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
 259     data
 260     |> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
 261     |> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
 262   end
 263
 264   defp maybe_put_role(data, _, _), do: data
 265
 266   defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
 267     Kernel.put_in(data, [:pleroma, :notification_settings], user.notification_settings)
 268   end
 269
 270   defp maybe_put_notification_settings(data, _, _), do: data
 271
 272   defp maybe_put_allow_following_move(data, %User{id: user_id} = user, %User{id: user_id}) do
 273     Kernel.put_in(data, [:pleroma, :allow_following_move], user.allow_following_move)
 274   end
 275
 276   defp maybe_put_allow_following_move(data, _, _), do: data
 277
 278   defp maybe_put_activation_status(data, user, %User{is_admin: true}) do
 279     Kernel.put_in(data, [:pleroma, :deactivated], user.deactivated)
 280   end
 281
 282   defp maybe_put_activation_status(data, _, _), do: data
 283
 284   defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
 285     data
 286     |> Kernel.put_in(
 287       [:pleroma, :unread_conversation_count],
 288       user.unread_conversation_count
 289     )
 290   end
 291
 292   defp maybe_put_unread_conversation_count(data, _, _), do: data
 293
 294   defp image_url(%{"url" => [%{"href" => href} | _]}), do: href
 295   defp image_url(_), do: nil
 296 end