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