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.FollowingRelationship
   9   alias Pleroma.User
  10   alias Pleroma.UserRelationship
  11   alias Pleroma.Web.CommonAPI.Utils
  12   alias Pleroma.Web.MastodonAPI.AccountView
  13   alias Pleroma.Web.MediaProxy
  14
  15   # Default behaviour for account view is to include embedded relationships
  16   #   (e.g. when accounts are rendered on their own [e.g. a list of search results], not as
  17   #   embedded content in notifications / statuses).
  18   # This option must be explicitly set to false when rendering accounts as embedded content.
  19   defp initialize_skip_relationships(opts) do
  20     Map.merge(%{skip_relationships: false}, opts)
  21   end
  22
  23   def render("index.json", %{users: users} = opts) do
  24     opts = initialize_skip_relationships(opts)
  25
  26     reading_user = opts[:for]
  27
  28     relationships_opt =
  29       cond do
  30         Map.has_key?(opts, :relationships) ->
  31           opts[:relationships]
  32
  33         is_nil(reading_user) || opts[:skip_relationships] ->
  34           UserRelationship.view_relationships_option(nil, [])
  35
  36         true ->
  37           UserRelationship.view_relationships_option(reading_user, users)
  38       end
  39
  40     opts = Map.put(opts, :relationships, relationships_opt)
  41
  42     users
  43     |> render_many(AccountView, "show.json", opts)
  44     |> Enum.filter(&Enum.any?/1)
  45   end
  46
  47   def render("show.json", %{user: user} = opts) do
  48     if User.visible_for?(user, opts[:for]) do
  49       do_render("show.json", opts)
  50     else
  51       %{}
  52     end
  53   end
  54
  55   def render("mention.json", %{user: user}) do
  56     %{
  57       id: to_string(user.id),
  58       acct: user.nickname,
  59       username: username_from_nickname(user.nickname),
  60       url: user.uri || user.ap_id
  61     }
  62   end
  63
  64   def render("relationship.json", %{user: nil, target: _target}) do
  65     %{}
  66   end
  67
  68   def render(
  69         "relationship.json",
  70         %{user: %User{} = reading_user, target: %User{} = target} = opts
  71       ) do
  72     user_relationships = get_in(opts, [:relationships, :user_relationships])
  73     following_relationships = get_in(opts, [:relationships, :following_relationships])
  74
  75     follow_state =
  76       if following_relationships do
  77         user_to_target_following_relation =
  78           FollowingRelationship.find(following_relationships, reading_user, target)
  79
  80         User.get_follow_state(reading_user, target, user_to_target_following_relation)
  81       else
  82         User.get_follow_state(reading_user, target)
  83       end
  84
  85     followed_by =
  86       if following_relationships do
  87         case FollowingRelationship.find(following_relationships, target, reading_user) do
  88           %{state: :follow_accept} -> true
  89           _ -> false
  90         end
  91       else
  92         User.following?(target, reading_user)
  93       end
  94
  95     # NOTE: adjust UserRelationship.view_relationships_option/2 on new relation-related flags
  96     %{
  97       id: to_string(target.id),
  98       following: follow_state == :follow_accept,
  99       followed_by: followed_by,
 100       blocking:
 101         UserRelationship.exists?(
 102           user_relationships,
 103           :block,
 104           reading_user,
 105           target,
 106           &User.blocks_user?(&1, &2)
 107         ),
 108       blocked_by:
 109         UserRelationship.exists?(
 110           user_relationships,
 111           :block,
 112           target,
 113           reading_user,
 114           &User.blocks_user?(&1, &2)
 115         ),
 116       muting:
 117         UserRelationship.exists?(
 118           user_relationships,
 119           :mute,
 120           reading_user,
 121           target,
 122           &User.mutes?(&1, &2)
 123         ),
 124       muting_notifications:
 125         UserRelationship.exists?(
 126           user_relationships,
 127           :notification_mute,
 128           reading_user,
 129           target,
 130           &User.muted_notifications?(&1, &2)
 131         ),
 132       subscribing:
 133         UserRelationship.exists?(
 134           user_relationships,
 135           :inverse_subscription,
 136           target,
 137           reading_user,
 138           &User.subscribed_to?(&2, &1)
 139         ),
 140       requested: follow_state == :follow_pending,
 141       domain_blocking: User.blocks_domain?(reading_user, target),
 142       showing_reblogs:
 143         not UserRelationship.exists?(
 144           user_relationships,
 145           :reblog_mute,
 146           reading_user,
 147           target,
 148           &User.muting_reblogs?(&1, &2)
 149         ),
 150       endorsed: false
 151     }
 152   end
 153
 154   def render("relationships.json", %{user: user, targets: targets} = opts) do
 155     relationships_opt =
 156       cond do
 157         Map.has_key?(opts, :relationships) ->
 158           opts[:relationships]
 159
 160         is_nil(user) ->
 161           UserRelationship.view_relationships_option(nil, [])
 162
 163         true ->
 164           UserRelationship.view_relationships_option(user, targets)
 165       end
 166
 167     render_opts = %{as: :target, user: user, relationships: relationships_opt}
 168     render_many(targets, AccountView, "relationship.json", render_opts)
 169   end
 170
 171   defp do_render("show.json", %{user: user} = opts) do
 172     opts = initialize_skip_relationships(opts)
 173
 174     user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
 175     display_name = user.name || user.nickname
 176
 177     image = User.avatar_url(user) |> MediaProxy.url()
 178     header = User.banner_url(user) |> MediaProxy.url()
 179
 180     following_count =
 181       if !user.hide_follows_count or !user.hide_follows or opts[:for] == user do
 182         user.following_count || 0
 183       else
 184         0
 185       end
 186
 187     followers_count =
 188       if !user.hide_followers_count or !user.hide_followers or opts[:for] == user do
 189         user.follower_count || 0
 190       else
 191         0
 192       end
 193
 194     bot = user.actor_type in ["Application", "Service"]
 195
 196     emojis =
 197       Enum.map(user.emoji, fn {shortcode, url} ->
 198         %{
 199           "shortcode" => shortcode,
 200           "url" => url,
 201           "static_url" => url,
 202           "visible_in_picker" => false
 203         }
 204       end)
 205
 206     relationship =
 207       if opts[:skip_relationships] do
 208         %{}
 209       else
 210         render("relationship.json", %{
 211           user: opts[:for],
 212           target: user,
 213           relationships: opts[:relationships]
 214         })
 215       end
 216
 217     %{
 218       id: to_string(user.id),
 219       username: username_from_nickname(user.nickname),
 220       acct: user.nickname,
 221       display_name: display_name,
 222       locked: user.locked,
 223       created_at: Utils.to_masto_date(user.inserted_at),
 224       followers_count: followers_count,
 225       following_count: following_count,
 226       statuses_count: user.note_count,
 227       note: user.bio || "",
 228       url: user.uri || user.ap_id,
 229       avatar: image,
 230       avatar_static: image,
 231       header: header,
 232       header_static: header,
 233       emojis: emojis,
 234       fields: user.fields,
 235       bot: bot,
 236       source: %{
 237         note: prepare_user_bio(user),
 238         sensitive: false,
 239         fields: user.raw_fields,
 240         pleroma: %{
 241           discoverable: user.discoverable,
 242           actor_type: user.actor_type
 243         }
 244       },
 245
 246       # Pleroma extension
 247       pleroma: %{
 248         confirmation_pending: user.confirmation_pending,
 249         tags: user.tags,
 250         hide_followers_count: user.hide_followers_count,
 251         hide_follows_count: user.hide_follows_count,
 252         hide_followers: user.hide_followers,
 253         hide_follows: user.hide_follows,
 254         hide_favorites: user.hide_favorites,
 255         relationship: relationship,
 256         skip_thread_containment: user.skip_thread_containment,
 257         background_image: image_url(user.background) |> MediaProxy.url()
 258       }
 259     }
 260     |> maybe_put_role(user, opts[:for])
 261     |> maybe_put_settings(user, opts[:for], opts)
 262     |> maybe_put_notification_settings(user, opts[:for])
 263     |> maybe_put_settings_store(user, opts[:for], opts)
 264     |> maybe_put_chat_token(user, opts[:for], opts)
 265     |> maybe_put_activation_status(user, opts[:for])
 266     |> maybe_put_follow_requests_count(user, opts[:for])
 267     |> maybe_put_allow_following_move(user, opts[:for])
 268     |> maybe_put_unread_conversation_count(user, opts[:for])
 269     |> maybe_put_unread_notification_count(user, opts[:for])
 270   end
 271
 272   defp prepare_user_bio(%User{bio: ""}), do: ""
 273
 274   defp prepare_user_bio(%User{bio: bio}) when is_binary(bio) do
 275     bio |> String.replace(~r(<br */?>), "\n") |> Pleroma.HTML.strip_tags()
 276   end
 277
 278   defp prepare_user_bio(_), do: ""
 279
 280   defp username_from_nickname(string) when is_binary(string) do
 281     hd(String.split(string, "@"))
 282   end
 283
 284   defp username_from_nickname(_), do: nil
 285
 286   defp maybe_put_follow_requests_count(
 287          data,
 288          %User{id: user_id} = user,
 289          %User{id: user_id}
 290        ) do
 291     count =
 292       User.get_follow_requests(user)
 293       |> length()
 294
 295     data
 296     |> Kernel.put_in([:follow_requests_count], count)
 297   end
 298
 299   defp maybe_put_follow_requests_count(data, _, _), do: data
 300
 301   defp maybe_put_settings(
 302          data,
 303          %User{id: user_id} = user,
 304          %User{id: user_id},
 305          _opts
 306        ) do
 307     data
 308     |> Kernel.put_in([:source, :privacy], user.default_scope)
 309     |> Kernel.put_in([:source, :pleroma, :show_role], user.show_role)
 310     |> Kernel.put_in([:source, :pleroma, :no_rich_text], user.no_rich_text)
 311   end
 312
 313   defp maybe_put_settings(data, _, _, _), do: data
 314
 315   defp maybe_put_settings_store(data, %User{} = user, %User{}, %{
 316          with_pleroma_settings: true
 317        }) do
 318     data
 319     |> Kernel.put_in([:pleroma, :settings_store], user.pleroma_settings_store)
 320   end
 321
 322   defp maybe_put_settings_store(data, _, _, _), do: data
 323
 324   defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
 325          with_chat_token: token
 326        }) do
 327     data
 328     |> Kernel.put_in([:pleroma, :chat_token], token)
 329   end
 330
 331   defp maybe_put_chat_token(data, _, _, _), do: data
 332
 333   defp maybe_put_role(data, %User{show_role: true} = user, _) do
 334     data
 335     |> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
 336     |> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
 337   end
 338
 339   defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
 340     data
 341     |> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
 342     |> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
 343   end
 344
 345   defp maybe_put_role(data, _, _), do: data
 346
 347   defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
 348     Kernel.put_in(data, [:pleroma, :notification_settings], user.notification_settings)
 349   end
 350
 351   defp maybe_put_notification_settings(data, _, _), do: data
 352
 353   defp maybe_put_allow_following_move(data, %User{id: user_id} = user, %User{id: user_id}) do
 354     Kernel.put_in(data, [:pleroma, :allow_following_move], user.allow_following_move)
 355   end
 356
 357   defp maybe_put_allow_following_move(data, _, _), do: data
 358
 359   defp maybe_put_activation_status(data, user, %User{is_admin: true}) do
 360     Kernel.put_in(data, [:pleroma, :deactivated], user.deactivated)
 361   end
 362
 363   defp maybe_put_activation_status(data, _, _), do: data
 364
 365   defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
 366     data
 367     |> Kernel.put_in(
 368       [:pleroma, :unread_conversation_count],
 369       user.unread_conversation_count
 370     )
 371   end
 372
 373   defp maybe_put_unread_conversation_count(data, _, _), do: data
 374
 375   defp maybe_put_unread_notification_count(data, %User{id: user_id}, %User{id: user_id} = user) do
 376     Kernel.put_in(
 377       data,
 378       [:pleroma, :unread_notifications_count],
 379       Pleroma.Notification.unread_notifications_count(user)
 380     )
 381   end
 382
 383   defp maybe_put_unread_notification_count(data, _, _), do: data
 384
 385   defp image_url(%{"url" => [%{"href" => href} | _]}), do: href
 386   defp image_url(_), do: nil
 387 end