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