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